From e116f0ce8f0e5558b3384a183f65a856dcbded38 Mon Sep 17 00:00:00 2001 From: rain Date: Wed, 4 Nov 2026 13:05:39 +0800 Subject: [PATCH 01/18] fix(daemon): reclaim control slots after retained connection failure (#540) A worker that failed after decoding a request left its admission slot 'Retained' forever: no product path called take_connection_failure, nothing logged the retained cause, and after all 8 slots were retained the daemon closed every new connection. sandbox.get/close/workspace.* then failed Busy and only killing the daemon recovered. Release the slot immediately for every worker result and move retained failures into a bounded, TTL-pruned operator-visible store (limit 64, TTL 1h). Log every retained failure to stderr/daemon.log in the same ConnectionFailure style as released ones, including request kind, whether a reply was sent, and the bounded cause. Expose the store through backend.daemon.connection_failures alongside vacant/running slot counts. Make the client refusal name only what it observed: a daemon that closes before Hello has no vacant control slot (Busy), while a broken/reset connection is a connection failure (Unavailable); stop claiming that other processes hold all connections. Bound sandbox.close's phase-stop status refresh to 2s so a refusing daemon yields an exact refusal instead of holding the op intent for the full 60s admission wait. Tests: an end-to-end daemon test sends 12 failing requests that die before a reply, asserts every slot is reclaimed, the failures are stored/queryable and a new authenticated client is admitted; unit tests cover the bounded ring, TTL pruning and the precise client refusal messages. --- .../layerfs-control/src/common/trace.rs | 13 + .../layerfs-control/src/daemon/operator.rs | 21 +- api/crates/layerfs-control/src/daemon/pool.rs | 232 ++++++++++-- .../layerfs-control/src/sandbox/files.rs | 29 +- .../layerfs-control/src/sandbox/serve.rs | 9 +- .../src/application/connection.rs | 350 ++++++++++++++++-- .../layerfs-daemon/src/application/failure.rs | 3 +- .../layerfs-daemon/src/application/mod.rs | 2 + .../layerfs-daemon/src/application/owner.rs | 121 ++++-- .../src/application/retained.rs | 316 ++++++++++++++++ 10 files changed, 992 insertions(+), 104 deletions(-) create mode 100644 engine/crates/layerfs-daemon/src/application/retained.rs diff --git a/api/crates/layerfs-control/src/common/trace.rs b/api/crates/layerfs-control/src/common/trace.rs index aa3aa14df8..d734afaf2d 100644 --- a/api/crates/layerfs-control/src/common/trace.rs +++ b/api/crates/layerfs-control/src/common/trace.rs @@ -86,6 +86,19 @@ pub(crate) fn control(controls: &Controls) -> Result, SdkRefusal> { internal::trace(&mut lease, SCOPE.get()); Ok(Traced(lease)) } + +/// [`control`], waiting at most `wait` for admission and for an in-use +/// connection. A short-wait caller reports the daemon's exact refusal instead +/// of holding its operation intent for the whole admission wait (#540). +pub(crate) fn control_within( + controls: &Controls, + wait: Duration, +) -> Result, SdkRefusal> { + let (mut lease, waited) = controls.lend_within(wait)?; + WAITED.set(WAITED.get() + waited); + internal::trace(&mut lease, SCOPE.get()); + Ok(Traced(lease)) +} impl Drop for Traced<'_> { fn drop(&mut self) { let telemetry = internal::take_telemetry(&mut self.0); diff --git a/api/crates/layerfs-control/src/daemon/operator.rs b/api/crates/layerfs-control/src/daemon/operator.rs index 57fe3ac49e..2d84d2a5b0 100644 --- a/api/crates/layerfs-control/src/daemon/operator.rs +++ b/api/crates/layerfs-control/src/daemon/operator.rs @@ -2,16 +2,23 @@ use crate::{internal::Control, SdkError, SdkResult}; use layerfs_bridge::control::{SdkRefusal, SdkValue}; -/// Calls the daemon's read model that lists its Workspaces -/// (`sandbox.list_workspaces`), the one daemon backend method the host -/// Sandbox code sends; any other is refused before it is sent. +/// Calls one daemon backend method: the read model that lists its +/// Workspaces (`sandbox.list_workspaces`), or the operator view of control +/// admission and retained connection failures +/// (`backend.daemon.connection_failures`, #540). Any other method is refused +/// before it is sent. pub fn call(control: &mut Control, method: &str, args: SdkValue) -> SdkResult { - if method != "sandbox.list_workspaces" { - return Err(SdkError::Refused(SdkRefusal { + match method { + // The daemon's control admission and bounded retained-failure store + // (#540): an operator read model, never a product operation. + "backend.daemon.connection_failures" => { + crate::daemon::call::exchange_call(control, method, args) + } + "sandbox.list_workspaces" => crate::daemon::call::exchange_call(control, method, args), + _ => Err(SdkError::Refused(SdkRefusal { code: "UnknownMethod".into(), message: format!("no daemon backend method {method}"), detail: SdkValue::Null, - })); + })), } - crate::daemon::call::exchange_call(control, method, args) } diff --git a/api/crates/layerfs-control/src/daemon/pool.rs b/api/crates/layerfs-control/src/daemon/pool.rs index d51b0a7acf..e9e9ebf3fa 100644 --- a/api/crates/layerfs-control/src/daemon/pool.rs +++ b/api/crates/layerfs-control/src/daemon/pool.rs @@ -60,24 +60,88 @@ pub(crate) const ADMISSION_WAIT: Duration = Duration::from_secs(60); /// before it ends, and its `Busy` refusal is not retried. pub(crate) const LEND_WAIT: Duration = ADMISSION_WAIT; -/// Whether a failed open is the daemon closing a connection it did not admit: -/// the stream ended before the Hello reply. Through a port proxy the client -/// reads the end (`UnexpectedEof`); dialing the daemon directly, its handshake -/// write can meet the closed socket first (`BrokenPipe`, `ConnectionReset`). -/// Nothing but Hello was sent, so no operation was attempted and opening -/// again is safe. -fn not_admitted(refusal: &SdkRefusal) -> bool { - refusal.code == "Failed" - && ["UnexpectedEof", "BrokenPipe", "ConnectionReset"] - .iter() - .any(|kind| refusal.message.contains(kind)) +/// Why an open ended before the daemon's Hello reply. Both mean the call was +/// not admitted and nothing was attempted, so opening again is safe; they +/// name different observable causes. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +enum NotAdmitted { + /// The daemon accepted the socket, then closed it before Hello: it had no + /// vacant control slot (the accept loop's capacity refusal). + NoVacantSlot, + /// The connection itself failed before Hello (`BrokenPipe`, + /// `ConnectionReset`). + ConnectionFailed, +} + +impl NotAdmitted { + fn code(self) -> &'static str { + match self { + Self::NoVacantSlot => "Busy", + Self::ConnectionFailed => "Unavailable", + } + } + + fn detail(self) -> &'static str { + match self { + Self::NoVacantSlot => "no-vacant-slot", + Self::ConnectionFailed => "connection-failed", + } + } +} + +/// Classify a failed open that never reached the Hello reply. Through a port +/// proxy the client reads the end (`UnexpectedEof`, a clean close by the +/// daemon's accept loop); dialing the daemon directly, its handshake write can +/// meet the closed socket first (`BrokenPipe`, `ConnectionReset`). The old +/// message claimed "other processes hold all 8 connections"; that is not +/// knowledge the client has (#540). +fn not_admitted(refusal: &SdkRefusal) -> Option<(NotAdmitted, &'static str)> { + if refusal.code != "Failed" { + return None; + } + if refusal.message.contains("UnexpectedEof") { + return Some((NotAdmitted::NoVacantSlot, "UnexpectedEof")); + } + for kind in ["BrokenPipe", "ConnectionReset"] { + if refusal.message.contains(kind) { + return Some((NotAdmitted::ConnectionFailed, kind)); + } + } + None +} + +/// The exact refusal after `wait`: what the client observed, not a guess at +/// what another process is doing. +fn admission_refusal(wait: Duration, admission: NotAdmitted, kind: &str) -> SdkRefusal { + let message = match admission { + NotAdmitted::NoVacantSlot => format!( + "the Sandbox's daemon admitted no control connection for {}s: it closed the \ + connection before Hello ({kind}), which it does when it has no vacant control \ + slot. The call was not admitted", + wait.as_secs() + ), + NotAdmitted::ConnectionFailed => format!( + "the connection to the Sandbox's daemon failed before Hello for {}s ({kind}): \ + the call was not admitted", + wait.as_secs() + ), + }; + SdkRefusal { + code: admission.code().to_owned(), + message, + detail: SdkValue::map([ + ("admission", SdkValue::text(admission.detail())), + ("io", SdkValue::text(kind)), + ]), + } } impl Dial { /// The first connection a process opens to a Sandbox. While the daemon - /// admits no more connections (other processes hold all of them), waits - /// for one to be released, up to [`ADMISSION_WAIT`], instead of failing - /// the caller's operation with a bare `UnexpectedEof`. + /// refuses admission, waits for one to be released, up to + /// [`ADMISSION_WAIT`], instead of failing the caller's operation with a + /// bare `UnexpectedEof`. Its final refusal names what the client actually + /// observed: no vacant control slot, or a failed connection (#540). pub(crate) fn open_waiting(&self) -> Result { self.open_admitted(ADMISSION_WAIT) } @@ -88,20 +152,16 @@ impl Dial { let mut pause = Duration::from_millis(20); loop { match self.open() { - Err(refusal) if not_admitted(&refusal) && started.elapsed() < wait => { - std::thread::sleep(pause); - pause = (pause * 2).min(Duration::from_millis(500)); - } - Err(refusal) if not_admitted(&refusal) => { - return Err(refused( - "Busy", - format!( - "the Sandbox's daemon admitted no connection for {}s: other processes hold all {} of its connections", - wait.as_secs(), - crate::sandbox::serve::DAEMON_CONNECTIONS - ), - )) - } + Err(refusal) => match not_admitted(&refusal) { + Some(_) if started.elapsed() < wait => { + std::thread::sleep(pause); + pause = (pause * 2).min(Duration::from_millis(500)); + } + Some((admission, kind)) => { + return Err(admission_refusal(wait, admission, kind)) + } + None => return Err(refusal), + }, other => return other, } } @@ -175,6 +235,14 @@ impl Controls { /// A connection for one call, and how long the call waited for it. pub(crate) fn lend(&self) -> Result<(Lease<'_>, Duration), SdkRefusal> { + self.lend_within(LEND_WAIT) + } + + /// [`Controls::lend`], waiting at most `wait` for admission and for an + /// in-use connection. A caller that must not hold an operation intent + /// while a daemon refuses connections (an explicit close) uses a short + /// wait and reports the exact refusal (#540). + pub(crate) fn lend_within(&self, wait: Duration) -> Result<(Lease<'_>, Duration), SdkRefusal> { let started = Instant::now(); let poisoned = || refused("Failed", "binding state poisoned"); let mut pool = self.pool.lock().map_err(|_| poisoned())?; @@ -188,7 +256,7 @@ impl Controls { let only = pool.open == 1; drop(pool); let opened = if only { - self.dial.open_waiting() + self.dial.open_admitted(wait) } else { self.dial.open() }; @@ -206,14 +274,14 @@ impl Controls { } } } - let remaining = LEND_WAIT.saturating_sub(started.elapsed()); + let remaining = wait.saturating_sub(started.elapsed()); if remaining.is_zero() { return Err(refused( "Busy", format!( "all {} of this process's connections to the Sandbox stayed in use for {}s; nothing was attempted", pool.open, - LEND_WAIT.as_secs() + wait.as_secs() ), )); } @@ -267,3 +335,105 @@ impl DerefMut for Lease<'_> { self.control.as_mut().expect("lent connection") } } + +#[cfg(test)] +mod tests { + use super::*; + use std::net::TcpListener; + use std::thread; + + fn failed_open(message: &str) -> SdkRefusal { + refused("Failed", message) + } + + #[test] + fn clean_close_before_hello_is_no_vacant_slot() { + assert_eq!( + not_admitted(&failed_open("Io(Kind(UnexpectedEof))")), + Some((NotAdmitted::NoVacantSlot, "UnexpectedEof")) + ); + } + + #[test] + fn transport_errors_before_hello_are_connection_failures() { + for kind in ["BrokenPipe", "ConnectionReset"] { + assert_eq!( + not_admitted(&failed_open(&format!("Io(Kind({kind}))"))), + Some((NotAdmitted::ConnectionFailed, kind)) + ); + } + } + + #[test] + fn other_refusals_are_not_admission_refusals() { + assert_eq!(not_admitted(&refused("StaleSandbox", "saved daemon")), None); + assert_eq!(not_admitted(&failed_open("Io(Kind(TimedOut))")), None); + } + + #[test] + fn admission_refusal_names_only_what_was_observed() { + let capacity = admission_refusal( + Duration::from_secs(60), + NotAdmitted::NoVacantSlot, + "UnexpectedEof", + ); + assert_eq!(capacity.code, "Busy"); + assert!(capacity.message.contains("no vacant control slot")); + assert!(capacity.message.contains("UnexpectedEof")); + assert!(!capacity.message.contains("other processes")); + assert_eq!( + capacity.detail.get_text("admission"), + Some("no-vacant-slot") + ); + + let failure = admission_refusal( + Duration::from_secs(60), + NotAdmitted::ConnectionFailed, + "ConnectionReset", + ); + assert_eq!(failure.code, "Unavailable"); + assert!(failure.message.contains("connection")); + assert!(failure.message.contains("ConnectionReset")); + assert!(!failure.message.contains("other processes")); + assert_eq!( + failure.detail.get_text("admission"), + Some("connection-failed") + ); + } + + #[test] + fn a_daemon_that_closes_before_hello_refuses_precisely() { + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let address = listener.local_addr().unwrap(); + // The daemon's accept loop with no vacant slot: accept once, close. + thread::spawn(move || { + for stream in listener.incoming() { + drop(stream); + } + }); + let dial = Dial { + endpoint: address, + host: None, + secret: [7; 32], + peer: layerfs_bridge::duplex::public_key(&[8; 32]).unwrap(), + instance: [9; 32], + }; + let Err(refusal) = dial.open_admitted(Duration::from_millis(120)) else { + panic!("a daemon that closes before Hello was admitted"); + }; + assert!( + matches!(refusal.code.as_str(), "Busy" | "Unavailable"), + "{refusal:?}" + ); + assert!( + !refusal.message.contains("other processes"), + "{}", + refusal.message + ); + assert!( + refusal.message.contains("not admitted"), + "{}", + refusal.message + ); + } +} diff --git a/api/crates/layerfs-control/src/sandbox/files.rs b/api/crates/layerfs-control/src/sandbox/files.rs index 2b2358d75f..cde1860c9d 100644 --- a/api/crates/layerfs-control/src/sandbox/files.rs +++ b/api/crates/layerfs-control/src/sandbox/files.rs @@ -572,6 +572,17 @@ pub(crate) fn refresh(state: &SandboxState) -> Result<()> { /// daemon for a Ready receipt that no longer exists. Other records still /// undergo the ordinary refresh and MountsActive admission. pub(crate) fn refresh_except(state: &SandboxState, retained: &[String]) -> Result<()> { + refresh_except_within(state, retained, crate::daemon::pool::ADMISSION_WAIT) +} + +/// [`refresh_except`], waiting at most `wait` for a daemon control connection. +/// An explicit close uses a short wait so its `op` intent is not held for the +/// whole admission wait while the daemon refuses connections (#540). +pub(crate) fn refresh_except_within( + state: &SandboxState, + retained: &[String], + wait: std::time::Duration, +) -> Result<()> { let mut mounts = std::collections::BTreeMap::new(); for (_, value) in workspaces(&state.directory)? { let path = registry::text(&value, "path")?; @@ -579,13 +590,17 @@ pub(crate) fn refresh_except(state: &SandboxState, retained: &[String]) -> Resul continue; } let token = token_of(&value)?; - let status = - match workspace(&mut *crate::common::trace::control(&state.controls)?).status(token) { - Ok(status) => status, - // Unmounted by the daemon; its owner removes the record next. - Err(failure) if absent(&failure) => continue, - Err(failure) => return Err(failed(failure)), - }; + let status = match workspace(&mut *crate::common::trace::control_within( + &state.controls, + wait, + )?) + .status(token) + { + Ok(status) => status, + // Unmounted by the daemon; its owner removes the record next. + Err(failure) if absent(&failure) => continue, + Err(failure) => return Err(failed(failure)), + }; let ready = status .kernel .and_then(|k| k.ready) diff --git a/api/crates/layerfs-control/src/sandbox/serve.rs b/api/crates/layerfs-control/src/sandbox/serve.rs index 55e1c28681..bf548a1104 100644 --- a/api/crates/layerfs-control/src/sandbox/serve.rs +++ b/api/crates/layerfs-control/src/sandbox/serve.rs @@ -37,6 +37,10 @@ const ENGINE: Duration = Duration::from_secs(30); /// A failed create's report keeps its daemon's last log lines, up to this many bytes. pub(crate) const LOG_LINES: u16 = 20; pub(crate) const LOG_BYTES: usize = 2048; +/// How long an explicit close waits for the daemon's Workspace status before +/// it returns the exact admission refusal. The close's `op` intent must not +/// be held for the whole admission wait (#540). +const CLOSE_STATUS_WAIT: Duration = Duration::from_secs(2); pub(crate) fn operation(failure: Box) -> SdkRefusal { values::refusal(&failure).unwrap_or_else(|| failed(failure)) @@ -510,7 +514,10 @@ pub(crate) fn close(args: &SdkValue) -> Outcome { }; let _guard = crate::sandbox::files::guard(&state.directory)?; let recoverable = crate::workspace::unmount_guard::check_all(&state)?; - crate::sandbox::files::refresh_except(&state, &recoverable)?; + // A daemon that refuses all control connections must refuse this close + // with its exact cause in bounded time, not hold the `op` intent while + // the SDK's ordinary 60 s admission wait runs out. + crate::sandbox::files::refresh_except_within(&state, &recoverable, CLOSE_STATUS_WAIT)?; // Explicit close can take over an orphaned/retained unmount, but must // still refuse every unrelated live Workspace. Stop detaches before // killing the daemon; Delete independently checks physical detach. diff --git a/engine/crates/layerfs-daemon/src/application/connection.rs b/engine/crates/layerfs-daemon/src/application/connection.rs index 4b60c75e13..ba154635ab 100644 --- a/engine/crates/layerfs-daemon/src/application/connection.rs +++ b/engine/crates/layerfs-daemon/src/application/connection.rs @@ -1,5 +1,5 @@ //! Bounded real authenticated connection workers and retained original failures. -use super::{owner::Slot, Application, ApplicationError, ConnectionFailure}; +use super::{owner::Finished, Application, ApplicationError, ConnectionFailure}; use layerfs_bridge::{ control::{Call, Reply, Request}, duplex::{self as transport}, @@ -10,25 +10,25 @@ use std::{ net::{TcpListener, TcpStream}, sync::Arc, thread, - time::Duration, + time::{Duration, Instant}, }; impl Application { /// Accepts ordinary authenticated controls on one listener. The listener and /// each admitted worker own their exact sockets; no command execution occurs. - /// A failed connection keeps its bounded slot/custody until explicit transfer. + /// A failed connection releases its slot at once; a compact record of a + /// failure that used to retain custody stays in the bounded store. pub fn serve(self: &Arc, listener: TcpListener) -> Result<(), ApplicationError> { loop { let (stream, _) = listener.accept().map_err(ApplicationError::Io)?; let slot = { let mut state = self.state.lock().map_err(|_| ApplicationError::Poisoned)?; - let Some(slot) = state.slots.iter().position(|v| matches!(v, Slot::Vacant)) else { + let Some(slot) = state.slots.admit() else { // No authenticated operation has entered; admission ends this // socket once, rather than allocating an unbounded worker. drop(stream); continue; }; - state.slots[slot] = Slot::Running; slot }; let previous = self @@ -47,34 +47,27 @@ impl Application { let worker = thread::Builder::new() .name(format!("layerfs-control-{slot}")) .spawn(move || { - let mut result = application.connection(stream, slot); - if let Err(failure) = &mut result { - if failure.original.is_none() - && failure.received.is_none() - && matches!( - failure.cause, - ApplicationError::Channel(_) | ApplicationError::Io(_) - ) - { - // No decoded product attempt/custody exists at this boundary. - // Transfer this bounded original diagnostic to the daemon - // stderr owner before releasing capacity. Failed transfer - // keeps the original receipt and its distinct output error. - match writeln!(std::io::stderr().lock(), "{failure:?}") { - Ok(()) => result = Ok(()), - Err(error) => failure.diagnostic_error = Some(error), - } - } - } - { - // Poison recovery retains this exact result only; poisoned - // state never authorizes another product operation. + let result = application.connection(stream, slot); + // Poison recovery records this exact result only; poisoned + // state never authorizes another product operation. The slot + // becomes Vacant even for a retained failure (#540): failure + // records live in a bounded store, not in admission capacity. + let finished = { let mut state = application.state.lock().unwrap_or_else(|e| e.into_inner()); - state.slots[slot] = match result { - Ok(()) => Slot::Vacant, - Err(cause) => Slot::Retained(Box::new(cause)), - }; + let finished = state.slots.finish(slot, result, Instant::now()); application.changed.notify_all(); + finished + }; + // Every retained failure is visible in daemon.log, in the + // same ConnectionFailure style as the released ones. + match finished { + Finished::Clean => {} + Finished::Released(failure) => { + let _ = writeln!(std::io::stderr().lock(), "{failure:?}"); + } + Finished::Retained(record) => { + let _ = writeln!(std::io::stderr().lock(), "{record}"); + } } }); match worker { @@ -84,15 +77,32 @@ impl Application { .map_err(|_| ApplicationError::Poisoned)?[slot] = Some(worker) } Err(cause) => { - let mut state = self.state.lock().map_err(|_| ApplicationError::Poisoned)?; - state.slots[slot] = Slot::Retained(Box::new(ConnectionFailure { + // The worker thread never ran. Release the slot and keep the + // same bounded operator-visible record as a failed worker. + let failure = ConnectionFailure { slot, received: None, original: None, cause: ApplicationError::Io(cause), fence_error: None, diagnostic_error: None, - })); + }; + let finished = { + let mut state = + self.state.lock().map_err(|_| ApplicationError::Poisoned)?; + let finished = state.slots.finish(slot, Err(failure), Instant::now()); + self.changed.notify_all(); + finished + }; + match finished { + Finished::Retained(record) => { + let _ = writeln!(std::io::stderr().lock(), "{record}"); + } + Finished::Released(failure) => { + let _ = writeln!(std::io::stderr().lock(), "{failure:?}"); + } + Finished::Clean => {} + } } } } @@ -319,6 +329,15 @@ impl Application { let service = state.startup.service.clone(); let phase = state.startup.phase; drop(state); + // Operator-visible retained failures live with the application, not + // with the Store control Service, so answer this one here. + if let Request::Sdk(call) = request { + if call.method == CONNECTION_FAILURES { + return self + .connection_failures() + .map(|value| Success::reply(Reply::Sdk(value))); + } + } match service { Some(service) => service.execute_control(request), None if phase == DaemonPhase::Retained => Err(Failure::Rejected( @@ -331,4 +350,267 @@ impl Application { )), } } + + /// The operator read model of control admission and retained failures. + fn connection_failures( + &self, + ) -> Result { + use crate::control::Failure; + use layerfs_bridge::control::SdkValue; + let (vacant, running) = self.connection_slots().map_err(|_| Failure::Poisoned)?; + let snapshot = self + .retained_connection_failures() + .map_err(|_| Failure::Poisoned)?; + let failures = snapshot + .failures + .iter() + .map(|failure| { + SdkValue::map([ + ("slot", SdkValue::Int(failure.slot as i64)), + ( + "received_bytes", + failure + .received_bytes + .map_or(SdkValue::Null, |bytes| SdkValue::Int(bytes as i64)), + ), + ( + "request", + failure.request.map_or(SdkValue::Null, SdkValue::text), + ), + ("reply_sent", SdkValue::Bool(failure.reply_sent)), + ("cause", SdkValue::text(&failure.cause)), + ( + "fence_error", + failure + .fence_error + .as_deref() + .map_or(SdkValue::Null, SdkValue::text), + ), + ( + "diagnostic_error", + failure + .diagnostic_error + .as_deref() + .map_or(SdkValue::Null, SdkValue::text), + ), + ("age_ms", SdkValue::Int(failure.age.as_millis() as i64)), + ]) + }) + .collect(); + Ok(SdkValue::map([ + ( + "admission", + SdkValue::map([ + ("vacant", SdkValue::Int(vacant as i64)), + ("running", SdkValue::Int(running as i64)), + ]), + ), + ("limit", SdkValue::Int(snapshot.limit as i64)), + ("ttl_ms", SdkValue::Int(snapshot.ttl.as_millis() as i64)), + ("dropped", SdkValue::Int(snapshot.dropped as i64)), + ("failures", SdkValue::List(failures)), + ])) + } +} + +/// Operator/control method for the daemon's control admission and retained +/// connection failures. +pub(super) const CONNECTION_FAILURES: &str = "backend.daemon.connection_failures"; + +#[cfg(test)] +mod tests { + use super::*; + use crate::application::owner::{Slots, Startup, State}; + use crate::{Owner, OwnerConfig}; + use layerfs_bridge::{ + control::{Answer, Call, DaemonPhase, HelloRequest, Reply, Request}, + daemon_setup::{DaemonLimits, DaemonSetup}, + store::DaemonStore, + KernelRoute, + }; + use layerfs_overlay::ProfileConfig; + use std::{ + net::TcpStream, + path::PathBuf, + process, + sync::{Condvar, Mutex}, + time::{Duration, Instant}, + }; + + const CONNECTIONS: u16 = 8; + const CLIENT_PRIVATE: [u8; 32] = [71; 32]; + const SERVER_PRIVATE: [u8; 32] = [72; 32]; + + fn temp_directory(label: &str) -> PathBuf { + use std::sync::atomic::{AtomicU64, Ordering}; + static NEXT: AtomicU64 = AtomicU64::new(0); + let directory = std::env::temp_dir().join(format!( + "layerfs-540-{}-{label}-{}", + process::id(), + NEXT.fetch_add(1, Ordering::Relaxed) + )); + std::fs::create_dir_all(directory.join("mounts")).unwrap(); + directory + } + + /// A real `Application` over an empty Store path: Hello and EndSession + /// need no Store service, and no kernel serving is assembled. + fn application(directory: &std::path::Path) -> Arc { + let owner = Owner::start( + &directory.join("overlay.sqlite"), + ProfileConfig::default(), + OwnerConfig::default(), + ) + .unwrap(); + let setup = DaemonSetup { + listen: "127.0.0.1:0".into(), + private_key: SERVER_PRIVATE, + control_peer: layerfs_bridge::duplex::public_key(&CLIENT_PRIVATE).unwrap(), + route: KernelRoute::Nfs, + overlay: directory.join("overlay.sqlite").display().to_string(), + mounts: directory.join("mounts").display().to_string(), + command_uid: 501, + command_gid: 20, + limits: DaemonLimits { + connections: CONNECTIONS, + handshake_ms: 2000, + cache_bytes: 1024 * 1024, + namespaces: 16, + pager_kib: 1024, + serial_low_water: 256, + }, + store: DaemonStore::Sqlite { + locator: directory.join("store.sqlite").display().to_string(), + install: None, + }, + }; + let slots = usize::from(CONNECTIONS) + 1; + Arc::new(Application { + instance: layerfs_bridge::duplex::public_key(&SERVER_PRIVATE).unwrap(), + setup, + owner, + kernel: None, + export: None, + state: Mutex::new(State { + startup: Startup { + // No Store service in this fixture; InstallPending is the + // observable phase whose Hello reply needs no Store facts. + phase: DaemonPhase::InstallPending, + service: None, + installed: None, + existing: None, + install_failure: None, + }, + slots: Slots::new(slots), + }), + changed: Condvar::new(), + workers: Mutex::new((0..slots).map(|_| None).collect()), + }) + } + + fn connect(address: std::net::SocketAddr) -> transport::Connection { + let stream = TcpStream::connect_timeout(&address, Duration::from_secs(2)).unwrap(); + stream + .set_read_timeout(Some(Duration::from_secs(2))) + .unwrap(); + stream + .set_write_timeout(Some(Duration::from_secs(2))) + .unwrap(); + transport::initiate( + stream, + &CLIENT_PRIVATE, + layerfs_bridge::duplex::public_key(&SERVER_PRIVATE).unwrap(), + ) + .unwrap() + } + + fn until(what: &str, check: impl Fn() -> bool) { + let started = Instant::now(); + while !check() { + assert!( + started.elapsed() < Duration::from_secs(5), + "timed out waiting for {what}" + ); + std::thread::sleep(Duration::from_millis(10)); + } + } + + /// Eight-plus clients send bytes and die before reading a reply. Every + /// retained failure must free its slot, be stored, and leave the daemon + /// admitting a new authenticated client (#540). + #[test] + fn retained_failures_do_not_consume_control_slots() { + let directory = temp_directory("slots"); + let application = application(&directory); + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let address = listener.local_addr().unwrap(); + let serving = application.clone(); + std::thread::spawn(move || { + let _ = serving.serve(listener); + }); + + let rounds = usize::from(CONNECTIONS) + 4; + for round in 0..rounds { + let mut connection = connect(address); + // Not a decodable initial record: the daemon counts a received + // request and retains its exact cause. The client then disappears + // without reading any reply. + connection + .send + .send(b"client-died-before-reading-reply") + .unwrap(); + drop(connection); + until("the retained failure to be recorded", || { + application + .retained_connection_failures() + .map(|snapshot| snapshot.failures.len() == round + 1) + .unwrap_or(false) + }); + let (vacant, _) = application.connection_slots().unwrap(); + assert!( + vacant > 0, + "round {round}: a retained failure consumed the last slot" + ); + } + + let snapshot = application.retained_connection_failures().unwrap(); + assert_eq!(snapshot.failures.len(), rounds); + assert!(snapshot.dropped <= 1); + let operator = application.connection_failures().unwrap(); + assert_eq!(operator.get_int("limit"), Some(64)); + assert_eq!( + operator.get("admission").and_then(|v| v.get_int("vacant")), + Some(usize::from(CONNECTIONS + 1) as i64) + ); + assert_eq!( + operator.get("failures").map(|v| match v { + layerfs_bridge::control::SdkValue::List(items) => items.len(), + _ => 0, + }), + Some(rounds) + ); + + let record = &snapshot.failures[0]; + assert_eq!(record.slot, 0); + assert!(record.received_bytes.is_some()); + assert!(record.cause.contains("kernel request"), "{}", record.cause); + assert!(!record.reply_sent); + + // A new authenticated client is admitted and receives its Hello reply. + let mut connection = connect(address); + let hello = Call { + id: 1, + request: Request::Hello(HelloRequest { + expected_instance: Some(application.instance), + wait_for_store: false, + }), + }; + connection.send.send(&hello.encode().unwrap()).unwrap(); + let answer = Answer::decode(connection.receive.receive().unwrap()).unwrap(); + match answer.reply { + Reply::Hello(status) => assert_eq!(status.phase, DaemonPhase::InstallPending), + other => panic!("unexpected Hello reply: {other:?}"), + } + drop(connection); + } } diff --git a/engine/crates/layerfs-daemon/src/application/failure.rs b/engine/crates/layerfs-daemon/src/application/failure.rs index cf9588d6da..e824e39731 100644 --- a/engine/crates/layerfs-daemon/src/application/failure.rs +++ b/engine/crates/layerfs-daemon/src/application/failure.rs @@ -69,7 +69,8 @@ impl fmt::Display for ApplicationError { impl std::error::Error for ApplicationError {} /// Original failed connection admission/dispatch result and input custody. pub struct ConnectionFailure { - /// Exact admitted slot identity; never recycled while this custody remains. + /// Exact admitted slot identity at the failure; the slot is released once + /// this result is recorded, so a later connection may occupy it. pub slot: usize, /// Original malformed metadata bytes only; successful requests own decoded fields. pub received: Option>, diff --git a/engine/crates/layerfs-daemon/src/application/mod.rs b/engine/crates/layerfs-daemon/src/application/mod.rs index 76671b12a8..65427ebb16 100644 --- a/engine/crates/layerfs-daemon/src/application/mod.rs +++ b/engine/crates/layerfs-daemon/src/application/mod.rs @@ -7,9 +7,11 @@ mod diagnostics; mod failure; mod filesystem; mod owner; +mod retained; mod serve; pub use cli::main; pub use diagnostics::resources::{ResourceDiagnosticError, ResourceFailure, ResourceObservation}; pub(crate) use diagnostics::{commit_parts, namespace_values, storage_values}; pub use failure::{ApplicationError, ConnectionFailure}; pub use owner::Application; +pub use retained::{RetainedFailure, RetainedSnapshot}; diff --git a/engine/crates/layerfs-daemon/src/application/owner.rs b/engine/crates/layerfs-daemon/src/application/owner.rs index 65b8472dda..55f4711c6c 100644 --- a/engine/crates/layerfs-daemon/src/application/owner.rs +++ b/engine/crates/layerfs-daemon/src/application/owner.rs @@ -1,4 +1,5 @@ //! One startup lifecycle owner, Store transfer and bounded connection custody. +use super::retained::{RetainedFailure, RetainedFailures, RetainedSnapshot}; use super::{ApplicationError, ConnectionFailure}; use crate::{ bootstrap::{open_store_observed, OpenedStore}, @@ -19,12 +20,97 @@ use layerfs_storage::ReservationBlocks; use std::{ sync::{Arc, Condvar, Mutex}, thread::JoinHandle, + time::Instant, }; pub(super) enum Slot { Vacant, Running, - Retained(Box), +} + +/// What finishing one connection did with its failure, if any. +pub(super) enum Finished { + /// The worker ended without a failure. + Clean, + /// The failure was written to the daemon log and needs no record. + Released(Box), + /// The failure was recorded in the bounded store; its slot is already free. + Retained(RetainedFailure), +} + +/// The fixed control-slot table and the bounded retained-failure store beside it. +/// +/// A retained failure never owns a slot: `finish` always leaves it `Vacant` +/// and only records the failure. Admission capacity therefore cannot leak +/// (#540). +pub(super) struct Slots { + slots: Vec, + retained: RetainedFailures, +} + +impl Slots { + pub(super) fn new(count: usize) -> Self { + Self { + slots: (0..count).map(|_| Slot::Vacant).collect(), + retained: RetainedFailures::default(), + } + } + + /// Claims one vacant slot, marking it `Running`, or `None` when every + /// slot is in use. + pub(super) fn admit(&mut self) -> Option { + let slot = self + .slots + .iter() + .position(|value| matches!(value, Slot::Vacant))?; + self.slots[slot] = Slot::Running; + Some(slot) + } + + /// Ends one worker: release its slot and, for a retained failure, record it. + pub(super) fn finish( + &mut self, + slot: usize, + result: Result<(), ConnectionFailure>, + now: Instant, + ) -> Finished { + let Some(current) = self.slots.get_mut(slot) else { + return Finished::Clean; + }; + *current = Slot::Vacant; + match result { + Ok(()) => Finished::Clean, + Err(failure) if releases_after_logging(&failure) => { + Finished::Released(Box::new(failure)) + } + Err(failure) => Finished::Retained(self.retained.record(&failure, now)), + } + } + + pub(super) fn snapshot(&mut self, now: Instant) -> RetainedSnapshot { + self.retained.snapshot(now) + } + + /// Vacant and running (in-use) slots. + pub(super) fn counts(&self) -> (usize, usize) { + let vacant = self + .slots + .iter() + .filter(|value| matches!(value, Slot::Vacant)) + .count(); + (vacant, self.slots.len() - vacant) + } +} + +/// A failure with no decoded product attempt or custody: the existing daemon +/// log line is the whole record, and the slot is released. +fn releases_after_logging(failure: &ConnectionFailure) -> bool { + failure.original.is_none() + && failure.received.is_none() + && matches!( + failure.cause, + ApplicationError::Channel(_) | ApplicationError::Io(_) + ) } pub(super) struct Startup { pub phase: DaemonPhase, @@ -35,7 +121,7 @@ pub(super) struct Startup { } pub(super) struct State { pub startup: Startup, - pub slots: Vec, + pub slots: Slots, } /// One real daemon application; Store/Overlay are initialized once and reused. pub struct Application { @@ -201,7 +287,7 @@ impl Application { existing, install_failure: None, }, - slots: (0..count).map(|_| Slot::Vacant).collect(), + slots: Slots::new(count), }), changed: Condvar::new(), workers: Mutex::new((0..count).map(|_| None).collect()), @@ -271,27 +357,16 @@ impl Application { } Ok(self.observation(&state)) } - /// Transfers original failed connection custody out only at an explicit operator request. - /// Taking a receipt does not resolve its unknowns, replay it or remove artifacts. - pub fn take_connection_failure( - &self, - slot: usize, - ) -> Result>, ApplicationError> { + /// The bounded retained-failure store, pruned at this observation. + pub fn retained_connection_failures(&self) -> Result { let mut state = self.state.lock().map_err(|_| ApplicationError::Poisoned)?; - let current = state.slots.get_mut(slot).ok_or_else(|| { - ApplicationError::Io(std::io::Error::new( - std::io::ErrorKind::InvalidInput, - "connection slot", - )) - })?; - if !matches!(current, Slot::Retained(_)) { - return Ok(None); - } - let Slot::Retained(failure) = std::mem::replace(current, Slot::Vacant) else { - unreachable!() - }; - self.changed.notify_all(); - Ok(Some(failure)) + Ok(state.slots.snapshot(Instant::now())) + } + + /// Vacant and in-use control slots. + pub fn connection_slots(&self) -> Result<(usize, usize), ApplicationError> { + let state = self.state.lock().map_err(|_| ApplicationError::Poisoned)?; + Ok(state.slots.counts()) } } diff --git a/engine/crates/layerfs-daemon/src/application/retained.rs b/engine/crates/layerfs-daemon/src/application/retained.rs new file mode 100644 index 0000000000..613548eedd --- /dev/null +++ b/engine/crates/layerfs-daemon/src/application/retained.rs @@ -0,0 +1,316 @@ +//! Bounded operator-visible records of connection failures that used to retain a slot. +//! +//! A failed connection worker used to keep its admission slot `Retained` until +//! an explicit transfer that no product path ever made. That cost one of the +//! daemon's fixed control slots per failure until every new connection was +//! refused (#540). The slot is now released at once; what survives here is a +//! compact, bounded record with its exact deciding cause. +use super::{ApplicationError, ConnectionFailure}; +use std::{ + collections::VecDeque, + fmt, + time::{Duration, Instant}, +}; + +/// Most retained records kept at once. The oldest is dropped first. +pub(super) const LIMIT: usize = 64; +/// How long a retained record stays operator-visible. +pub(super) const TTL: Duration = Duration::from_secs(60 * 60); +/// Most bytes a retained textual cause keeps. +const CAUSE_BYTES: usize = 512; + +/// One connection failure that used to retain its slot, as an operator sees it. +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct RetainedFailure { + /// Slot the failed worker occupied; it is already free for a new connection. + pub slot: usize, + /// Bytes of a request that failed decoding, when one was received. + pub received_bytes: Option, + /// `control` or `install` when a request was decoded, else `None`. + pub request: Option<&'static str>, + /// Whether the original reply was sent before the failure. + pub reply_sent: bool, + /// Bounded textual deciding cause. + pub cause: String, + /// Original socket fence failure, when one was observed. + pub fence_error: Option, + /// Distinct failed diagnostic transfer, when one happened. + pub diagnostic_error: Option, + /// Age at the observation that returned this record. + pub age: Duration, +} + +impl fmt::Display for RetainedFailure { + fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { + f.debug_struct("ConnectionFailure") + .field("slot", &self.slot) + .field("received_bytes", &self.received_bytes) + .field("original_kind", &self.request) + .field("reply", &if self.reply_sent { "sent" } else { "not_sent" }) + .field("cause", &self.cause) + .field("fence_error", &self.fence_error) + .field("diagnostic_error", &self.diagnostic_error) + .finish() + } +} + +/// A bounded observation of the retained-failure store. +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct RetainedSnapshot { + /// Records, oldest first. + pub failures: Vec, + /// Records evicted by the limit or the TTL since startup. + pub dropped: u64, + /// Configured record limit. + pub limit: usize, + /// Configured record TTL. + pub ttl: Duration, +} + +struct Entry { + record: RetainedFailure, + at: Instant, +} + +/// A fixed-capacity, TTL-pruned ring of retained connection failures. +pub(super) struct RetainedFailures { + entries: VecDeque, + dropped: u64, + limit: usize, + ttl: Duration, +} + +impl Default for RetainedFailures { + fn default() -> Self { + Self::new(LIMIT, TTL) + } +} + +impl RetainedFailures { + pub(super) fn new(limit: usize, ttl: Duration) -> Self { + Self { + entries: VecDeque::new(), + dropped: 0, + limit: limit.max(1), + ttl, + } + } + + /// Records one failure, prunes expired records and evicts the oldest + /// beyond the limit. Returns the exact record that now is visible. + pub(super) fn record(&mut self, failure: &ConnectionFailure, now: Instant) -> RetainedFailure { + self.prune(now); + while self.entries.len() >= self.limit { + self.entries.pop_front(); + self.dropped = self.dropped.saturating_add(1); + } + let record = describe(failure); + self.entries.push_back(Entry { + record: record.clone(), + at: now, + }); + record + } + + /// Drops records older than the TTL; a stale record is never returned. + pub(super) fn prune(&mut self, now: Instant) { + while let Some(front) = self.entries.front() { + if now.saturating_duration_since(front.at) < self.ttl { + break; + } + self.entries.pop_front(); + self.dropped = self.dropped.saturating_add(1); + } + } + + /// A copy of the visible records, oldest first, with their ages. + pub(super) fn snapshot(&mut self, now: Instant) -> RetainedSnapshot { + self.prune(now); + RetainedSnapshot { + failures: self + .entries + .iter() + .map(|entry| { + let mut record = entry.record.clone(); + record.age = now.saturating_duration_since(entry.at); + record + }) + .collect(), + dropped: self.dropped, + limit: self.limit, + ttl: self.ttl, + } + } + + #[cfg(test)] + pub(super) fn len(&self) -> usize { + self.entries.len() + } +} + +fn describe(failure: &ConnectionFailure) -> RetainedFailure { + let request = request_kind(failure); + let reply_sent = reply_sent(failure); + RetainedFailure { + slot: failure.slot, + received_bytes: failure.received.as_ref().map(Vec::len), + request, + reply_sent, + cause: bounded(&failure.cause.to_string()), + fence_error: failure + .fence_error + .as_ref() + .map(|error| bounded(&error.to_string())), + diagnostic_error: failure + .diagnostic_error + .as_ref() + .map(|error| bounded(&error.to_string())), + age: Duration::ZERO, + } +} + +/// Whether a request was decoded, from the direct field or the cause that +/// owns the original receipt. +fn request_kind(failure: &ConnectionFailure) -> Option<&'static str> { + if let Some(original) = &failure.original { + return Some(match original { + layerfs_bridge::initial_record::InitialRecord::Control(_) => "control", + layerfs_bridge::initial_record::InitialRecord::Install(_) => "install", + }); + } + match &failure.cause { + ApplicationError::Control(serve) => serve + .original + .as_ref() + .map(|served| kind(&served.call.request)), + ApplicationError::RetainedControl(served) => Some(kind(&served.call.request)), + ApplicationError::SessionEnd { served, .. } => Some(kind(&served.call.request)), + _ => None, + } +} + +fn kind(request: &layerfs_bridge::control::Request) -> &'static str { + use layerfs_bridge::control::Request; + match request { + Request::Mount { .. } => "mount", + Request::Commit(_) => "commit", + Request::Status(_) => "status", + Request::Unmount(_) => "unmount", + Request::ForceUnmount { .. } => "force-unmount", + Request::Attach(_) => "attach", + Request::Locate(_) => "locate", + Request::Cleanup(_) => "cleanup", + Request::Fork(_) => "fork", + Request::Branches { .. } => "branches", + Request::History(_) => "history", + Request::Sdk(_) => "sdk", + Request::Hello(_) => "hello", + Request::EndSession => "end-session", + Request::Observed { .. } => "observed", + } +} + +/// Whether the original reply reached the caller. A send/fence failure did +/// not; a retained receipt or a session-end observation follows a sent reply. +fn reply_sent(failure: &ConnectionFailure) -> bool { + matches!( + failure.cause, + ApplicationError::RetainedControl(_) | ApplicationError::SessionEnd { .. } + ) +} + +fn bounded(text: &str) -> String { + if text.len() <= CAUSE_BYTES { + return text.to_owned(); + } + let mut end = CAUSE_BYTES; + while !text.is_char_boundary(end) { + end -= 1; + } + format!("{}…", &text[..end]) +} + +#[cfg(test)] +mod tests { + use super::*; + use crate::control::{Served, Success}; + use layerfs_bridge::control::{Call, Reply, Request}; + use layerfs_bridge::duplex::{ChannelError, ChannelWork, PeerEndFailure, PeerEndPhase}; + + /// A failure after the daemon sent EndSession's reply: what a client that + /// dies before reading it leaves behind. + fn retained_after_reply(slot: usize) -> ConnectionFailure { + ConnectionFailure { + slot, + received: None, + original: None, + cause: ApplicationError::SessionEnd { + served: Box::new(Served { + call: Call { + id: 1, + request: Request::EndSession, + }, + outcome: Ok(Success::reply(Reply::SessionEnded)), + }), + ending: Box::new(PeerEndFailure { + cause: ChannelError::Invalid("peer reset after final reply"), + phase: PeerEndPhase::Read, + fence_attempted: false, + received: None, + work: ChannelWork::default(), + }), + }, + fence_error: None, + diagnostic_error: None, + } + } + + #[test] + fn limit_evicts_oldest_and_counts_drops() { + let mut store = RetainedFailures::new(3, TTL); + let now = Instant::now(); + for slot in 0..5 { + store.record(&retained_after_reply(slot), now); + } + assert_eq!(store.len(), 3); + let snapshot = store.snapshot(now); + assert_eq!(snapshot.dropped, 2); + assert_eq!( + snapshot.failures.iter().map(|f| f.slot).collect::>(), + vec![2, 3, 4] + ); + assert_eq!(snapshot.limit, 3); + assert_eq!(snapshot.ttl, TTL); + } + + #[test] + fn ttl_prunes_expired_records() { + let mut store = RetainedFailures::new(8, Duration::from_secs(10)); + let now = Instant::now(); + store.record(&retained_after_reply(1), now); + store.record(&retained_after_reply(2), now + Duration::from_secs(5)); + let snapshot = store.snapshot(now + Duration::from_secs(9)); + assert_eq!(snapshot.failures.len(), 2); + let snapshot = store.snapshot(now + Duration::from_secs(16)); + assert_eq!(snapshot.failures.len(), 0); + assert_eq!(snapshot.dropped, 2); + } + + #[test] + fn record_names_the_cause_request_and_reply_state() { + let mut store = RetainedFailures::new(8, TTL); + let now = Instant::now(); + let record = store.record(&retained_after_reply(3), now); + assert_eq!(record.slot, 3); + assert_eq!(record.request, Some("end-session")); + assert!(record.reply_sent); + assert!(record.cause.contains("session"), "{}", record.cause); + let line = record.to_string(); + assert!(line.starts_with("ConnectionFailure {"), "{line}"); + assert!( + line.contains("original_kind: Some(\"end-session\")"), + "{line}" + ); + assert!(line.contains("reply: \"sent\""), "{line}"); + } +} From 7cfe4460e454918b89e89b693b3af4d4ebacb182 Mon Sep 17 00:00:00 2001 From: rain Date: Wed, 4 Nov 2026 13:21:08 +0800 Subject: [PATCH 02/18] fix(daemon): complete slot-class isolation and capacity notice (#540) Extend the slot reclamation fix to the full recovery design while keeping the released-slot invariant. - Slot table: pool and reserved classes with generation-checked SlotTicket. Admission scans only its own class; a pool claim never takes the reserved installer slot and vice versa. A stale or duplicate finish changes nothing. - Panic/spawn safety: the worker runs under catch_unwind and owns a SlotGuard. Exactly one finish happens on the normal path, a panic, a dropped thread or a spawn failure; the synthetic cause is recorded, not lost. - Retained store: records now carry class, generation, owner (instance, pid, thread), visible count and expiry; the ring pre-reserves capacity, tracks recorded and is reaped lazily when admission is refused. Still 64 / 1h. - Capacity notice: a fixed advisory pre-handshake LAYERFS-CAPACITY frame (version/reason/retained/pool_vacant/reserved_vacant) is written before closing when no slot is free. The client decodes it before the Noise message and returns Capacity { resource: "daemon_control_slot", retained, retryable: true }; a bare EOF still maps to Capacity with retained null, resets map to Unavailable, and a random record is never accepted. - Host query: backend.daemon.connection_failures is dispatched to the host, works for forwarded Sandboxes, and sandbox.get exposes it best-effort as daemon_capacity. The operator query is nested admission/retained. - Close/unmount deadline: refresh uses one total deadline for all Workspace status probes (close 2s, unmount 5s), and force close skips the probe so it can stop a refusing daemon instead of waiting N times. Tests: daemon 13 (class isolation, stale finish, guard release, capacity notice, 16 concurrent failures, retained store); control 8 (notice -> precise Capacity, EOF fallback, reset -> Unavailable, garbage rejected); bridge 2. --- api/crates/layerfs-control/src/daemon/pool.rs | 289 +++++++--- .../layerfs-control/src/sandbox/direct.rs | 4 +- .../layerfs-control/src/sandbox/dispatch.rs | 3 + .../layerfs-control/src/sandbox/files.rs | 19 +- api/crates/layerfs-control/src/sandbox/get.rs | 39 ++ .../layerfs-control/src/sandbox/serve.rs | 16 +- .../layerfs-control/src/workspace/serve.rs | 10 +- .../layerfs-bridge/src/duplex/admission.rs | 158 ++++++ .../crates/layerfs-bridge/src/duplex/error.rs | 12 + .../layerfs-bridge/src/duplex/handshake.rs | 5 + .../crates/layerfs-bridge/src/duplex/mod.rs | 1 + .../src/application/connection.rs | 501 +++++++++++++++--- .../layerfs-daemon/src/application/failure.rs | 3 + .../layerfs-daemon/src/application/owner.rs | 308 +++++++++-- .../src/application/retained.rs | 163 ++++-- 15 files changed, 1307 insertions(+), 224 deletions(-) create mode 100644 engine/crates/layerfs-bridge/src/duplex/admission.rs diff --git a/api/crates/layerfs-control/src/daemon/pool.rs b/api/crates/layerfs-control/src/daemon/pool.rs index e9e9ebf3fa..75b1993d2f 100644 --- a/api/crates/layerfs-control/src/daemon/pool.rs +++ b/api/crates/layerfs-control/src/daemon/pool.rs @@ -14,7 +14,10 @@ use crate::common::outcome::{failed, refused}; use crate::internal::Control; use layerfs_bridge::control::{DaemonPhase, HelloRequest, Reply, Request, SdkRefusal, SdkValue}; -use layerfs_bridge::duplex::initiate_observed; +use layerfs_bridge::duplex::{ + admission::{AdmissionNotice, AdmissionReason}, + initiate_observed, ChannelError, +}; use std::net::SocketAddr; use std::ops::{Deref, DerefMut}; use std::sync::{Condvar, Mutex}; @@ -60,14 +63,16 @@ pub(crate) const ADMISSION_WAIT: Duration = Duration::from_secs(60); /// before it ends, and its `Busy` refusal is not retried. pub(crate) const LEND_WAIT: Duration = ADMISSION_WAIT; -/// Why an open ended before the daemon's Hello reply. Both mean the call was -/// not admitted and nothing was attempted, so opening again is safe; they -/// name different observable causes. +/// Why an open ended before the daemon's Hello reply. Every one means the +/// call was not admitted and nothing was attempted, so opening again is +/// safe; they name different observable causes (#540). #[derive(Clone, Copy, Debug, Eq, PartialEq)] enum NotAdmitted { - /// The daemon accepted the socket, then closed it before Hello: it had no - /// vacant control slot (the accept loop's capacity refusal). - NoVacantSlot, + /// The daemon had no vacant pool slot. `retained` is exact when the + /// advisory capacity notice arrived, and unknown when only EOF was seen. + NoVacantSlot { retained: Option }, + /// The daemon is still starting and admits no control yet. + Starting, /// The connection itself failed before Hello (`BrokenPipe`, /// `ConnectionReset`). ConnectionFailed, @@ -76,14 +81,15 @@ enum NotAdmitted { impl NotAdmitted { fn code(self) -> &'static str { match self { - Self::NoVacantSlot => "Busy", - Self::ConnectionFailed => "Unavailable", + Self::NoVacantSlot { .. } => "Capacity", + Self::Starting | Self::ConnectionFailed => "Unavailable", } } - fn detail(self) -> &'static str { + fn admission(self) -> &'static str { match self { - Self::NoVacantSlot => "no-vacant-slot", + Self::NoVacantSlot { .. } => "no-vacant-slot", + Self::Starting => "starting", Self::ConnectionFailed => "connection-failed", } } @@ -100,7 +106,10 @@ fn not_admitted(refusal: &SdkRefusal) -> Option<(NotAdmitted, &'static str)> { return None; } if refusal.message.contains("UnexpectedEof") { - return Some((NotAdmitted::NoVacantSlot, "UnexpectedEof")); + return Some(( + NotAdmitted::NoVacantSlot { retained: None }, + "UnexpectedEof", + )); } for kind in ["BrokenPipe", "ConnectionReset"] { if refusal.message.contains(kind) { @@ -110,32 +119,94 @@ fn not_admitted(refusal: &SdkRefusal) -> Option<(NotAdmitted, &'static str)> { None } +/// The exact refusal for a decoded advisory capacity notice. This is the +/// precise form: it names the resource and the retained record count. +fn notice_refusal(notice: AdmissionNotice) -> SdkRefusal { + match notice.reason { + AdmissionReason::NoPoolSlot | AdmissionReason::ReservedBusy => SdkRefusal { + code: "Capacity".to_owned(), + message: format!( + "the Sandbox's daemon has no vacant control slot: {} pool slot(s) and {} reserved slot(s) are vacant, with {} retained failure record(s). The call was not admitted; retrying is safe", + notice.pool_vacant, notice.reserved_vacant, notice.retained + ), + detail: SdkValue::map([ + ("resource", SdkValue::text("daemon_control_slot")), + ("retained", SdkValue::Int(i64::from(notice.retained))), + ("pool_vacant", SdkValue::Int(i64::from(notice.pool_vacant))), + ( + "reserved_vacant", + SdkValue::Int(i64::from(notice.reserved_vacant)), + ), + ("retryable", SdkValue::Bool(true)), + ("admission", SdkValue::text(notice.reason.as_str())), + ]), + }, + AdmissionReason::Starting => SdkRefusal { + code: "Unavailable".to_owned(), + message: "the Sandbox's daemon is still starting and admits no control connection yet. The call was not admitted; retrying is safe" + .to_owned(), + detail: SdkValue::map([ + ("resource", SdkValue::Null), + ("retained", SdkValue::Null), + ("retryable", SdkValue::Bool(true)), + ("admission", SdkValue::text("starting")), + ]), + }, + } +} + /// The exact refusal after `wait`: what the client observed, not a guess at /// what another process is doing. fn admission_refusal(wait: Duration, admission: NotAdmitted, kind: &str) -> SdkRefusal { let message = match admission { - NotAdmitted::NoVacantSlot => format!( - "the Sandbox's daemon admitted no control connection for {}s: it closed the \ - connection before Hello ({kind}), which it does when it has no vacant control \ - slot. The call was not admitted", + NotAdmitted::NoVacantSlot { retained } => format!( + "the Sandbox's daemon admitted no control connection for {}s: it closed the connection before Hello ({kind}), which it does when it has no vacant control slot{}. The call was not admitted; retrying is safe", + wait.as_secs(), + retained.map_or(String::new(), |count| format!( + " (it reported {count} retained failure record(s))" + )) + ), + NotAdmitted::Starting => format!( + "the Sandbox's daemon is still starting and admitted no control connection for {}s ({kind}). The call was not admitted; retrying is safe", wait.as_secs() ), NotAdmitted::ConnectionFailed => format!( - "the connection to the Sandbox's daemon failed before Hello for {}s ({kind}): \ - the call was not admitted", + "the connection to the Sandbox's daemon failed before Hello for {}s ({kind}): the call was not admitted; retrying is safe", wait.as_secs() ), }; + let retained = match admission { + NotAdmitted::NoVacantSlot { retained } => { + retained.map_or(SdkValue::Null, |count| SdkValue::Int(i64::from(count))) + } + _ => SdkValue::Null, + }; SdkRefusal { code: admission.code().to_owned(), message, detail: SdkValue::map([ - ("admission", SdkValue::text(admission.detail())), - ("io", SdkValue::text(kind)), + ( + "resource", + match admission { + NotAdmitted::NoVacantSlot { .. } => SdkValue::text("daemon_control_slot"), + _ => SdkValue::Null, + }, + ), + ("retained", retained), + ("retryable", SdkValue::Bool(true)), + ("admission", SdkValue::text(admission.admission())), + ("observed", SdkValue::text(kind)), ]), } } +/// Whether this refusal says nothing was attempted and a later open may +/// succeed. Only these exact refusals are retried. +fn retryable(refusal: &SdkRefusal) -> bool { + matches!(refusal.code.as_str(), "Capacity" | "Unavailable") + && refusal.detail.get_bool("retryable") +} + impl Dial { /// The first connection a process opens to a Sandbox. While the daemon /// refuses admission, waits for one to be released, up to @@ -152,16 +223,20 @@ impl Dial { let mut pause = Duration::from_millis(20); loop { match self.open() { - Err(refusal) => match not_admitted(&refusal) { - Some(_) if started.elapsed() < wait => { + Err(refusal) => { + let legacy = not_admitted(&refusal); + let may_retry = retryable(&refusal) || legacy.is_some(); + if may_retry && started.elapsed() < wait { std::thread::sleep(pause); pause = (pause * 2).min(Duration::from_millis(500)); + continue; } - Some((admission, kind)) => { - return Err(admission_refusal(wait, admission, kind)) + if let Some((admission, kind)) = legacy { + return Err(admission_refusal(wait, admission, kind)); } - None => return Err(refusal), - }, + // A notice-based or transport refusal is already exact. + return Err(refusal); + } other => return other, } } @@ -179,9 +254,11 @@ impl Dial { stream .set_write_timeout(Some(Duration::from_secs(10))) .map_err(failed)?; - let connection = initiate_observed(stream, &self.secret, self.peer) - .result - .map_err(failed)?; + let connection = match initiate_observed(stream, &self.secret, self.peer).result { + Ok(connection) => connection, + Err(ChannelError::Admission(notice)) => return Err(notice_refusal(notice)), + Err(error) => return Err(failed(error)), + }; connection.clear_io_waits().map_err(failed)?; let mut control = Control::new(connection); match control @@ -339,6 +416,8 @@ impl DerefMut for Lease<'_> { #[cfg(test)] mod tests { use super::*; + use layerfs_bridge::duplex::admission::encode; + use std::io::Write; use std::net::TcpListener; use std::thread; @@ -347,19 +426,52 @@ mod tests { } #[test] - fn clean_close_before_hello_is_no_vacant_slot() { + fn eof_fallback_is_capacity_with_unknown_retained() { + let (admission, kind) = not_admitted(&failed_open("Io(Kind(UnexpectedEof))")).unwrap(); + assert_eq!(kind, "UnexpectedEof"); + assert!(matches!( + admission, + NotAdmitted::NoVacantSlot { retained: None } + )); + let capacity = admission_refusal(Duration::from_secs(60), admission, kind); + assert_eq!(capacity.code, "Capacity"); + assert!(capacity.message.contains("no vacant control slot")); + assert!(capacity.message.contains("UnexpectedEof")); + assert!(!capacity.message.contains("other processes")); + assert_eq!( + capacity.detail.get_text("resource"), + Some("daemon_control_slot") + ); + assert!(matches!( + capacity.detail.get("retained"), + Some(SdkValue::Null) + )); + assert_eq!(capacity.detail.get_bool("retryable"), true); assert_eq!( - not_admitted(&failed_open("Io(Kind(UnexpectedEof))")), - Some((NotAdmitted::NoVacantSlot, "UnexpectedEof")) + capacity.detail.get_text("admission"), + Some("no-vacant-slot") ); } #[test] - fn transport_errors_before_hello_are_connection_failures() { + fn reset_is_unavailable() { for kind in ["BrokenPipe", "ConnectionReset"] { + let (admission, observed) = + not_admitted(&failed_open(&format!("Io(Kind({kind}))"))).unwrap(); + assert_eq!(observed, kind); + assert_eq!(admission, NotAdmitted::ConnectionFailed); + let failure = admission_refusal(Duration::from_secs(60), admission, kind); + assert_eq!(failure.code, "Unavailable"); + assert!(failure.message.contains(kind)); + assert!(!failure.message.contains("other processes")); + assert!(matches!( + failure.detail.get("resource"), + Some(SdkValue::Null) + )); + assert_eq!(failure.detail.get_bool("retryable"), true); assert_eq!( - not_admitted(&failed_open(&format!("Io(Kind({kind}))"))), - Some((NotAdmitted::ConnectionFailed, kind)) + failure.detail.get_text("admission"), + Some("connection-failed") ); } } @@ -371,34 +483,53 @@ mod tests { } #[test] - fn admission_refusal_names_only_what_was_observed() { - let capacity = admission_refusal( - Duration::from_secs(60), - NotAdmitted::NoVacantSlot, - "UnexpectedEof", - ); - assert_eq!(capacity.code, "Busy"); - assert!(capacity.message.contains("no vacant control slot")); - assert!(capacity.message.contains("UnexpectedEof")); - assert!(!capacity.message.contains("other processes")); + fn notice_maps_to_capacity_with_exact_retained() { + let notice = AdmissionNotice::new(AdmissionReason::NoPoolSlot, 8, 0, 1); + let refusal = notice_refusal(notice); + assert_eq!(refusal.code, "Capacity"); + assert_eq!(refusal.detail.get_int("retained"), Some(8)); + assert_eq!(refusal.detail.get_int("pool_vacant"), Some(0)); + assert_eq!(refusal.detail.get_int("reserved_vacant"), Some(1)); + assert_eq!(refusal.detail.get_bool("retryable"), true); assert_eq!( - capacity.detail.get_text("admission"), - Some("no-vacant-slot") + refusal.detail.get_text("resource"), + Some("daemon_control_slot") ); + assert!(!refusal.message.contains("other processes")); + } - let failure = admission_refusal( - Duration::from_secs(60), - NotAdmitted::ConnectionFailed, - "ConnectionReset", - ); - assert_eq!(failure.code, "Unavailable"); - assert!(failure.message.contains("connection")); - assert!(failure.message.contains("ConnectionReset")); - assert!(!failure.message.contains("other processes")); - assert_eq!( - failure.detail.get_text("admission"), - Some("connection-failed") - ); + #[test] + fn starting_notice_is_unavailable() { + let refusal = notice_refusal(AdmissionNotice::new(AdmissionReason::Starting, 0, 0, 1)); + assert_eq!(refusal.code, "Unavailable"); + assert_eq!(refusal.detail.get_text("admission"), Some("starting")); + assert_eq!(refusal.detail.get_bool("retryable"), true); + } + + #[test] + fn garbage_before_hello_is_not_a_notice() { + // A 24-byte record that is not the magic is a handshake failure, not + // a false Capacity. + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let address = listener.local_addr().unwrap(); + thread::spawn(move || { + for mut stream in listener.incoming().flatten() { + let _ = stream.write_all(&[0u8; 26]); + } + }); + let dial = Dial { + endpoint: address, + host: None, + secret: [7; 32], + peer: layerfs_bridge::duplex::public_key(&[8; 32]).unwrap(), + instance: [9; 32], + }; + let refusal = match dial.open_admitted(Duration::from_millis(80)) { + Ok(_) => panic!("a refusing daemon admitted the dial"), + Err(refusal) => refusal, + }; + assert_ne!(refusal.code, "Capacity", "{refusal:?}"); + assert!(!refusal.message.contains("other processes")); } #[test] @@ -421,10 +552,7 @@ mod tests { let Err(refusal) = dial.open_admitted(Duration::from_millis(120)) else { panic!("a daemon that closes before Hello was admitted"); }; - assert!( - matches!(refusal.code.as_str(), "Busy" | "Unavailable"), - "{refusal:?}" - ); + assert_eq!(refusal.code, "Capacity", "{refusal:?}"); assert!( !refusal.message.contains("other processes"), "{}", @@ -436,4 +564,37 @@ mod tests { refusal.message ); } + + #[test] + fn a_capacity_notice_is_classified_before_hello() { + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let address = listener.local_addr().unwrap(); + thread::spawn(move || { + for mut stream in listener.incoming().flatten() { + let body = encode(&AdmissionNotice::new(AdmissionReason::NoPoolSlot, 8, 0, 1)); + let mut framed = vec![0u8; 2 + body.len()]; + framed[..2].copy_from_slice(&(body.len() as u16).to_be_bytes()); + framed[2..].copy_from_slice(&body); + let _ = stream.write_all(&framed); + let _ = stream.shutdown(std::net::Shutdown::Write); + // Drain so the client's shutdown is not a reset. + let mut sink = [0u8; 64]; + let _ = std::io::Read::read(&mut stream, &mut sink); + } + }); + let dial = Dial { + endpoint: address, + host: None, + secret: [7; 32], + peer: layerfs_bridge::duplex::public_key(&[8; 32]).unwrap(), + instance: [9; 32], + }; + let refusal = match dial.open_admitted(Duration::from_millis(80)) { + Ok(_) => panic!("a refusing daemon admitted the dial"), + Err(refusal) => refusal, + }; + assert_eq!(refusal.code, "Capacity", "{refusal:?}"); + assert_eq!(refusal.detail.get_int("retained"), Some(8)); + assert_eq!(refusal.detail.get_bool("retryable"), true); + } } diff --git a/api/crates/layerfs-control/src/sandbox/direct.rs b/api/crates/layerfs-control/src/sandbox/direct.rs index 5e3959edbd..ad3c2e9703 100644 --- a/api/crates/layerfs-control/src/sandbox/direct.rs +++ b/api/crates/layerfs-control/src/sandbox/direct.rs @@ -344,7 +344,9 @@ pub(crate) fn call( (found == id).then_some(head) }) } - "sandbox.list_workspaces" => dispatch::call(op, args), + "sandbox.list_workspaces" | "backend.daemon.connection_failures" => { + dispatch::call(op, args) + } _ => Err(refused( "InvalidInput", format!("{op} is not sent to a Sandbox's daemon directly"), diff --git a/api/crates/layerfs-control/src/sandbox/dispatch.rs b/api/crates/layerfs-control/src/sandbox/dispatch.rs index bc2f37d2d0..d4b0003614 100644 --- a/api/crates/layerfs-control/src/sandbox/dispatch.rs +++ b/api/crates/layerfs-control/src/sandbox/dispatch.rs @@ -25,6 +25,9 @@ pub fn call(op: &str, args: SdkValue) -> Outcome { let directory = crate::sandbox::files::sandbox_dir(&args)?; listed(daemon_backend(op, args)?, &directory) } + // The operator view of control admission and retained failures + // (#540). It is a read model, never a product operation. + "backend.daemon.connection_failures" => daemon_backend(op, args), "sandbox.create" => crate::sandbox::serve::create(&args), "sandbox.close" => crate::sandbox::serve::close(&args), "workspace.mount" => workspace::mount(&args), diff --git a/api/crates/layerfs-control/src/sandbox/files.rs b/api/crates/layerfs-control/src/sandbox/files.rs index cde1860c9d..4c62f864b8 100644 --- a/api/crates/layerfs-control/src/sandbox/files.rs +++ b/api/crates/layerfs-control/src/sandbox/files.rs @@ -568,6 +568,13 @@ fn recorded_identity(value: &SdkValue) -> CommandIdentity { pub(crate) fn refresh(state: &SandboxState) -> Result<()> { refresh_except(state, &[]) } + +/// [`refresh`], waiting at most `wait` in total for all status probes. An +/// unmount uses a short bound so a refusing daemon returns its exact refusal +/// instead of blocking behind the folder guard (#540). +pub(crate) fn refresh_within(state: &SandboxState, wait: std::time::Duration) -> Result<()> { + refresh_except_within(state, &[], wait) +} /// Explicit Sandbox close may dispose retained unmounts without asking their /// daemon for a Ready receipt that no longer exists. Other records still /// undergo the ordinary refresh and MountsActive admission. @@ -575,14 +582,17 @@ pub(crate) fn refresh_except(state: &SandboxState, retained: &[String]) -> Resul refresh_except_within(state, retained, crate::daemon::pool::ADMISSION_WAIT) } -/// [`refresh_except`], waiting at most `wait` for a daemon control connection. -/// An explicit close uses a short wait so its `op` intent is not held for the -/// whole admission wait while the daemon refuses connections (#540). +/// [`refresh_except`], waiting at most `wait` in total for all Workspace +/// status probes. One deadline is shared by every Workspace, so N records +/// cannot multiply the wait (#540). An explicit close uses a short wait so its +/// `op` intent is not held for the whole admission wait while the daemon +/// refuses connections. pub(crate) fn refresh_except_within( state: &SandboxState, retained: &[String], wait: std::time::Duration, ) -> Result<()> { + let deadline = std::time::Instant::now() + wait; let mut mounts = std::collections::BTreeMap::new(); for (_, value) in workspaces(&state.directory)? { let path = registry::text(&value, "path")?; @@ -590,9 +600,10 @@ pub(crate) fn refresh_except_within( continue; } let token = token_of(&value)?; + let remaining = deadline.saturating_duration_since(std::time::Instant::now()); let status = match workspace(&mut *crate::common::trace::control_within( &state.controls, - wait, + remaining, )?) .status(token) { diff --git a/api/crates/layerfs-control/src/sandbox/get.rs b/api/crates/layerfs-control/src/sandbox/get.rs index 10572da79f..a2d229d795 100644 --- a/api/crates/layerfs-control/src/sandbox/get.rs +++ b/api/crates/layerfs-control/src/sandbox/get.rs @@ -37,15 +37,54 @@ pub(super) fn get(context: &mut Context<'_>, args: &SdkValue) -> Outcome { Err(Unreached(why)) => (Vec::new(), Some(why.message), false), }; let (items, next) = page(all, args); + // Read the capacity model before `record` is shadowed by the shown value. + let daemon_capacity = daemon_capacity(context, &record, gone); let shown = record.to_sdk(View::Full); let shown = home::with_field(shown, "state", SdkValue::text(record.state(gone))); let mut record = home::with_field(shown, "workspaces", SdkValue::List(items)); if let Some(why) = down { record = home::with_field(record, "down_reason", SdkValue::Text(why)); } + // Best effort: an operator sees the daemon's control capacity and + // retained connection failures with the Sandbox, but a get never fails + // because that read did (#540). `daemon` is the record's hidden reopen + // field, so it is free for this read model. + if let Some(value) = daemon_capacity { + record = home::with_field(record, "daemon_capacity", value); + } Ok(home::with_field(record, "next_page_pos", next)) } +/// The daemon's `backend.daemon.connection_failures` read model, when the +/// Sandbox answers it. Nothing is attempted for a gone Sandbox, and any +/// refusal is simply omitted. +fn daemon_capacity( + context: &mut Context<'_>, + record: &crate::sandbox::record::SandboxRecord, + gone: bool, +) -> Option { + let _ = gone; + record.id()?; + let outcome = if direct::forwarded(record) { + direct::call( + context, + record, + "backend.daemon.connection_failures", + vec![], + ) + } else { + reach( + context, + record, + "backend.daemon.connection_failures", + vec![], + false, + ) + .ok()? + }; + outcome.ok() +} + /// Workspace `item` of Sandbox `sandbox` with its `ws` (#536 C3): /// `:` when it has a name, else `:`; and its /// `name` and `path` (null and the daemon's `directory` from a worker that diff --git a/api/crates/layerfs-control/src/sandbox/serve.rs b/api/crates/layerfs-control/src/sandbox/serve.rs index bf548a1104..32640f8f7e 100644 --- a/api/crates/layerfs-control/src/sandbox/serve.rs +++ b/api/crates/layerfs-control/src/sandbox/serve.rs @@ -513,11 +513,18 @@ pub(crate) fn close(args: &SdkValue) -> Outcome { Err(refusal) => return Err(refusal), }; let _guard = crate::sandbox::files::guard(&state.directory)?; + let force = args.get_bool("force"); let recoverable = crate::workspace::unmount_guard::check_all(&state)?; - // A daemon that refuses all control connections must refuse this close - // with its exact cause in bounded time, not hold the `op` intent while - // the SDK's ordinary 60 s admission wait runs out. - crate::sandbox::files::refresh_except_within(&state, &recoverable, CLOSE_STATUS_WAIT)?; + if !force { + // A daemon that refuses all control connections must refuse this close + // with its exact cause in bounded time, not hold the `op` intent while + // the SDK's ordinary 60 s admission wait runs out. One shared deadline + // bounds all Workspace probes; N Workspaces cannot multiply it. + crate::sandbox::files::refresh_except_within(&state, &recoverable, CLOSE_STATUS_WAIT)?; + } + // `force` is the recovery path: it skips the daemon status probe and stops + // the runtime anyway, reporting every Workspace it could not drain as + // `unknown` below. It is still never blocked by the daemon it stops. // Explicit close can take over an orphaned/retained unmount, but must // still refuse every unrelated live Workspace. Stop detaches before // killing the daemon; Delete independently checks physical detach. @@ -538,7 +545,6 @@ pub(crate) fn close(args: &SdkValue) -> Outcome { } } } - let force = args.get_bool("force"); if !mounted.is_empty() && !force { return Err(SdkRefusal { code: "MountsActive".to_owned(), diff --git a/api/crates/layerfs-control/src/workspace/serve.rs b/api/crates/layerfs-control/src/workspace/serve.rs index b5b257eda7..76bc4585dd 100644 --- a/api/crates/layerfs-control/src/workspace/serve.rs +++ b/api/crates/layerfs-control/src/workspace/serve.rs @@ -239,6 +239,11 @@ pub(crate) fn commit(args: &SdkValue) -> Outcome { values::commit(&reply) } +/// How long unmount's Workspace status probe waits for the daemon. After +/// slot reclamation the ordinary path succeeds; a truly exhausted daemon +/// returns `Capacity` in bounded time instead of blocking behind the guard. +const UNMOUNT_STATUS_WAIT: std::time::Duration = std::time::Duration::from_secs(5); + /// `workspace.unmount(ws, { discard?, force? })`: the daemon's answer. pub(crate) fn unmount(args: &SdkValue) -> Outcome { let state = sandbox(args)?; @@ -253,7 +258,10 @@ pub(crate) fn unmount(args: &SdkValue) -> Outcome { return crate::workspace::unmount_guard::repeat(&value); } let token = state.token(path)?; - crate::sandbox::files::refresh(&state)?; + // One short deadline, not the full admission wait: a Workspace unmount + // must not hold the folder guard while a refusing daemon keeps the + // ordinary 60 s control wait running (#540). + crate::sandbox::files::refresh_within(&state, UNMOUNT_STATUS_WAIT)?; // the daemon's kernel probe answers Busy for a process still holding it let attempt = crate::workspace::unmount_guard::begin(&state, token, path)?; drop(guard); diff --git a/engine/crates/layerfs-bridge/src/duplex/admission.rs b/engine/crates/layerfs-bridge/src/duplex/admission.rs new file mode 100644 index 0000000000..09ce650ca6 --- /dev/null +++ b/engine/crates/layerfs-bridge/src/duplex/admission.rs @@ -0,0 +1,158 @@ +//! The daemon's advisory pre-handshake capacity notice (#540). +//! +//! When the accept loop finds no vacant control slot it would otherwise just +//! drop the socket, leaving the caller with a bare EOF. This fixed, bounded +//! frame tells the caller which resource was exhausted and how many failure +//! records are retained, so the product refusal can name the real resource. +//! It is written *before* the Noise handshake and is therefore unauthenticated: +//! it admits nothing, carries no secret, and every operation still crosses the +//! authenticated handshake and authorization. A forged notice can at most +//! cause a retry, exactly like a forged reset. +use std::io::Write; +use std::net::TcpStream; + +/// Magic that starts a capacity notice body. +pub const MAGIC: &[u8; 16] = b"LAYERFS-CAPACITY"; +/// The only notice version this build writes or reads. +pub const VERSION: u8 = 1; +/// Length of the body after the two-byte record header. +pub const BODY_LEN: usize = 24; + +/// Why no connection was admitted. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub enum AdmissionReason { + /// Every pool slot was busy (or retained; the count is in `retained`). + NoPoolSlot = 1, + /// The daemon is still starting and admits no control yet. + Starting = 2, + /// The reserved slot is in use and only pool capacity was requested. + ReservedBusy = 3, +} + +impl AdmissionReason { + fn of(byte: u8) -> Option { + match byte { + 1 => Some(Self::NoPoolSlot), + 2 => Some(Self::Starting), + 3 => Some(Self::ReservedBusy), + _ => None, + } + } + + /// Stable text for a refusal detail. + pub fn as_str(self) -> &'static str { + match self { + Self::NoPoolSlot => "no-pool-slot", + Self::Starting => "starting", + Self::ReservedBusy => "reserved-busy", + } + } +} + +/// One decoded advisory notice. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub struct AdmissionNotice { + /// Notice format version (always [`VERSION`] for a decoded notice). + pub version: u8, + /// Why admission ended. + pub reason: AdmissionReason, + /// Visible retained failure records, saturating at 255. + pub retained: u8, + /// Vacant pool slots, saturating at 255. + pub pool_vacant: u8, + /// Vacant reserved slots, saturating at 255. + pub reserved_vacant: u8, +} + +impl AdmissionNotice { + /// A notice with the current format version. + pub fn new( + reason: AdmissionReason, + retained: u8, + pool_vacant: u8, + reserved_vacant: u8, + ) -> Self { + Self { + version: VERSION, + reason, + retained, + pool_vacant, + reserved_vacant, + } + } +} + +/// The exact 24-byte body of `notice`. +pub fn encode(notice: &AdmissionNotice) -> [u8; BODY_LEN] { + let mut body = [0u8; BODY_LEN]; + body[..16].copy_from_slice(MAGIC); + body[16] = notice.version; + body[17] = notice.reason as u8; + body[18] = notice.retained; + body[19] = notice.pool_vacant; + body[20] = notice.reserved_vacant; + body +} + +/// The notice in `bytes`, or `None` when the record is anything else. A +/// random record that is not exactly a valid notice is never accepted. +pub fn classify(bytes: &[u8]) -> Option { + if bytes.len() != BODY_LEN || &bytes[..16] != MAGIC { + return None; + } + if bytes[16] != VERSION { + return None; + } + let reason = AdmissionReason::of(bytes[17])?; + if bytes[21..].iter().any(|byte| *byte != 0) { + return None; + } + Some(AdmissionNotice { + version: bytes[16], + reason, + retained: bytes[18], + pool_vacant: bytes[19], + reserved_vacant: bytes[20], + }) +} + +/// Writes `notice` as one length-prefixed record, then forces the write end +/// shut. The caller sets the socket timeouts. +pub fn write(stream: &mut TcpStream, notice: &AdmissionNotice) -> std::io::Result<()> { + let body = encode(notice); + let mut framed = [0u8; 2 + BODY_LEN]; + framed[..2].copy_from_slice(&(BODY_LEN as u16).to_be_bytes()); + framed[2..].copy_from_slice(&body); + stream.write_all(&framed)?; + stream.flush()?; + stream.shutdown(std::net::Shutdown::Write) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn encode_and_classify_round_trip() { + let notice = AdmissionNotice::new(AdmissionReason::NoPoolSlot, 8, 0, 1); + let body = encode(¬ice); + assert_eq!(body.len(), BODY_LEN); + assert_eq!(&body[..16], MAGIC); + assert_eq!(classify(&body), Some(notice)); + } + + #[test] + fn garbage_is_not_a_notice() { + assert_eq!(classify(&[0u8; BODY_LEN]), None); + assert_eq!(classify(&[0u8; 23]), None); + let mut body = encode(&AdmissionNotice::new(AdmissionReason::NoPoolSlot, 1, 1, 1)); + body[16] = 2; + assert_eq!(classify(&body), None); + let mut body = encode(&AdmissionNotice::new(AdmissionReason::NoPoolSlot, 1, 1, 1)); + body[17] = 0; + assert_eq!(classify(&body), None); + let mut body = encode(&AdmissionNotice::new(AdmissionReason::NoPoolSlot, 1, 1, 1)); + body[23] = 1; + assert_eq!(classify(&body), None); + } +} diff --git a/engine/crates/layerfs-bridge/src/duplex/error.rs b/engine/crates/layerfs-bridge/src/duplex/error.rs index 68c62ca309..713f5af76a 100644 --- a/engine/crates/layerfs-bridge/src/duplex/error.rs +++ b/engine/crates/layerfs-bridge/src/duplex/error.rs @@ -1,4 +1,5 @@ //! Transport failures retain original crypto/I/O and failed close evidence. +use super::admission::AdmissionNotice; use std::{fmt, io}; /// One duplex channel failure, without retries or inferred product disposition. @@ -14,6 +15,9 @@ pub enum ChannelError { RecordLimit, /// The physical Noise nonce space is exhausted. NonceExhausted, + /// The daemon refused admission before the handshake and sent its advisory + /// capacity notice (#540). Nothing was attempted; retrying is safe. + Admission(AdmissionNotice), /// Either direction previously failed or explicitly closed this connection. Quarantined, /// Connection quarantine also failed to interrupt socket I/O. @@ -42,6 +46,14 @@ impl fmt::Display for ChannelError { Self::Invalid(what) => write!(f, "invalid duplex channel: {what}"), Self::RecordLimit => f.write_str("duplex record processing window exceeded"), Self::NonceExhausted => f.write_str("duplex Noise nonce exhausted"), + Self::Admission(notice) => write!( + f, + "daemon admission refused ({}): retained {}, pool vacant {}, reserved vacant {}", + notice.reason.as_str(), + notice.retained, + notice.pool_vacant, + notice.reserved_vacant + ), Self::Quarantined => f.write_str("duplex channel quarantined"), Self::CloseFailed { original, close } => { write!(f, "{original}; shutdown also failed: {close}") diff --git a/engine/crates/layerfs-bridge/src/duplex/handshake.rs b/engine/crates/layerfs-bridge/src/duplex/handshake.rs index c532092c12..ea01daefbe 100644 --- a/engine/crates/layerfs-bridge/src/duplex/handshake.rs +++ b/engine/crates/layerfs-bridge/src/duplex/handshake.rs @@ -91,6 +91,11 @@ fn handshake( work.crypto_output_bytes += n as u64; io::write_record(&mut stream, &output[..n], work)?; io::read_record(&mut stream, 256, &mut input, work)?; + // A daemon that could not admit this connection writes a fixed + // advisory notice instead of a Noise message; never treat it as one. + if let Some(notice) = super::admission::classify(&input) { + return Err(ChannelError::Admission(notice)); + } work.crypto_attempts += 1; work.crypto_input_bytes += input.len() as u64; let read = state.read_message(&input, &mut payload)?; diff --git a/engine/crates/layerfs-bridge/src/duplex/mod.rs b/engine/crates/layerfs-bridge/src/duplex/mod.rs index e0bd8b6a4c..82e3d39e03 100644 --- a/engine/crates/layerfs-bridge/src/duplex/mod.rs +++ b/engine/crates/layerfs-bridge/src/duplex/mod.rs @@ -1,4 +1,5 @@ //! One-attempt authenticated duplex channels with bounded borrowed records. +pub mod admission; mod channel; mod ending; mod error; diff --git a/engine/crates/layerfs-daemon/src/application/connection.rs b/engine/crates/layerfs-daemon/src/application/connection.rs index ba154635ab..1ac06bef3b 100644 --- a/engine/crates/layerfs-daemon/src/application/connection.rs +++ b/engine/crates/layerfs-daemon/src/application/connection.rs @@ -1,18 +1,140 @@ //! Bounded real authenticated connection workers and retained original failures. -use super::{owner::Finished, Application, ApplicationError, ConnectionFailure}; +use super::{ + owner::{AdmissionClass, Finished, SlotClass, SlotTicket}, + retained::RetainedFailure, + Application, ApplicationError, ConnectionFailure, +}; use layerfs_bridge::{ - control::{Call, Reply, Request}, - duplex::{self as transport}, + control::{Call, DaemonPhase, Reply, Request}, + duplex::{ + self as transport, + admission::{self as admission_notice, AdmissionNotice, AdmissionReason}, + }, initial_record::InitialRecord, }; use std::{ - io::Write, + io::{Read, Write}, net::{TcpListener, TcpStream}, sync::Arc, thread, time::{Duration, Instant}, }; +/// Bounded conversion of an admission count to the notice's one byte. +fn saturating(count: usize) -> u8 { + u8::try_from(count).unwrap_or(u8::MAX) +} + +/// Writes one advisory pre-handshake capacity notice and drains what the +/// caller may still send, so it reads the notice rather than a reset. Every +/// socket operation is bounded; failure is ignored (the socket ends anyway). +fn write_capacity_notice(stream: &mut TcpStream, notice: &AdmissionNotice) { + let _ = stream.set_write_timeout(Some(Duration::from_millis(100))); + let _ = stream.set_read_timeout(Some(Duration::from_millis(50))); + if admission_notice::write(stream, notice).is_err() { + return; + } + let mut sink = [0u8; 512]; + let _ = stream.read(&mut sink); +} + +/// A synthetic failure for a worker that panicked: bounded, and recorded +/// through the same one-finish path as any other failure. +fn panic_failure(ticket: SlotTicket, payload: Box) -> ConnectionFailure { + let message = payload + .downcast_ref::<&str>() + .map(|text| (*text).to_owned()) + .or_else(|| payload.downcast_ref::().cloned()) + .unwrap_or_else(|| "non-string panic payload".to_owned()); + let mut message = format!("connection worker panicked: {message}"); + if message.len() > 512 { + let mut end = 512; + while !message.is_char_boundary(end) { + end -= 1; + } + message.truncate(end); + message.push('…'); + } + ConnectionFailure { + slot: ticket.index, + received: None, + original: None, + cause: ApplicationError::Worker(message), + fence_error: None, + diagnostic_error: None, + } +} + +/// Owns one admission ticket. Exactly one `finish` happens: the explicit +/// call, or `Drop` during an unwind or a spawn failure. +struct SlotGuard { + application: Arc, + ticket: SlotTicket, + owner: String, + done: bool, +} + +impl SlotGuard { + fn finish(&mut self, result: Result<(), ConnectionFailure>) { + if self.done { + return; + } + self.done = true; + // Build the bounded record before taking the state lock. + let prebuilt = result.as_ref().err().map(|failure| { + RetainedFailure::describe( + failure, + self.ticket.class, + self.ticket.generation, + &self.owner, + ) + }); + // Poison recovery here only releases the slot and records; normal + // admission still reports `Poisoned` rather than trusting corrupt state. + let finished = { + let mut state = self + .application + .state + .lock() + .unwrap_or_else(|poisoned| poisoned.into_inner()); + let finished = state + .slots + .finish(self.ticket, result, prebuilt, Instant::now()); + self.application.changed.notify_all(); + finished + }; + log_finished(finished); + } +} + +impl Drop for SlotGuard { + fn drop(&mut self) { + if !self.done { + self.finish(Err(ConnectionFailure { + slot: self.ticket.index, + received: None, + original: None, + cause: ApplicationError::Worker("dropped before completion".to_owned()), + fence_error: None, + diagnostic_error: None, + })); + } + } +} + +/// One bounded daemon-log line per terminal transition. +fn log_finished(finished: Finished) { + match finished { + Finished::Clean | Finished::Stale => {} + Finished::Released(failure) => { + let _ = writeln!(std::io::stderr().lock(), "{failure:?}"); + } + Finished::Retained(record) => { + let _ = writeln!(std::io::stderr().lock(), "{record}"); + } + } +} + impl Application { /// Accepts ordinary authenticated controls on one listener. The listener and /// each admitted worker own their exact sockets; no command execution occurs. @@ -20,21 +142,50 @@ impl Application { /// failure that used to retain custody stays in the bounded store. pub fn serve(self: &Arc, listener: TcpListener) -> Result<(), ApplicationError> { loop { - let (stream, _) = listener.accept().map_err(ApplicationError::Io)?; - let slot = { + let (mut stream, _) = listener.accept().map_err(ApplicationError::Io)?; + let ticket = { let mut state = self.state.lock().map_err(|_| ApplicationError::Poisoned)?; - let Some(slot) = state.slots.admit() else { - // No authenticated operation has entered; admission ends this - // socket once, rather than allocating an unbounded worker. - drop(stream); - continue; - }; - slot + let picked = state.slots.admit(AdmissionClass::ControlPool).or_else(|| { + // Only while the one-time installer may still run: an + // ordinary control never takes the reserved slot. + if matches!( + state.startup.phase, + DaemonPhase::InstallPending | DaemonPhase::Installing + ) { + state.slots.admit(AdmissionClass::Install) + } else { + None + } + }); + match picked { + Some(ticket) => ticket, + None => { + let counts = state.slots.counts(); + let retained = state.slots.visible(); + state.slots.reap(Instant::now()); + let reason = if state.startup.phase != DaemonPhase::ControlReady { + AdmissionReason::Starting + } else { + AdmissionReason::NoPoolSlot + }; + let notice = AdmissionNotice::new( + reason, + saturating(retained), + saturating(counts.pool_vacant), + saturating(counts.reserved_vacant), + ); + drop(state); + // No authenticated operation has entered; tell the + // caller why once, then end the socket (#540). + write_capacity_notice(&mut stream, ¬ice); + continue; + } + } }; let previous = self .workers .lock() - .map_err(|_| ApplicationError::Poisoned)?[slot] + .map_err(|_| ApplicationError::Poisoned)?[ticket.index] .take(); if let Some(worker) = previous { worker.join().map_err(|_| { @@ -44,70 +195,55 @@ impl Application { })?; } let application = self.clone(); + let owner = self.owner_label(ticket); + // The guard owns the ticket: if the worker body unwinds (or the + // thread never starts), it releases the slot and records exactly + // once. The normal path calls `finish` explicitly, so no path can + // leak a slot (#540). + let guard = SlotGuard { + application: self.clone(), + ticket, + owner, + done: false, + }; let worker = thread::Builder::new() - .name(format!("layerfs-control-{slot}")) + .name(format!("layerfs-control-{}", ticket.index)) .spawn(move || { - let result = application.connection(stream, slot); - // Poison recovery records this exact result only; poisoned - // state never authorizes another product operation. The slot - // becomes Vacant even for a retained failure (#540): failure - // records live in a bounded store, not in admission capacity. - let finished = { - let mut state = application.state.lock().unwrap_or_else(|e| e.into_inner()); - let finished = state.slots.finish(slot, result, Instant::now()); - application.changed.notify_all(); - finished - }; - // Every retained failure is visible in daemon.log, in the - // same ConnectionFailure style as the released ones. - match finished { - Finished::Clean => {} - Finished::Released(failure) => { - let _ = writeln!(std::io::stderr().lock(), "{failure:?}"); - } - Finished::Retained(record) => { - let _ = writeln!(std::io::stderr().lock(), "{record}"); - } - } + let mut guard = guard; + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + application.connection(stream, ticket) + })) + .unwrap_or_else(|payload| Err(panic_failure(ticket, payload))); + guard.finish(result); }); match worker { Ok(worker) => { self.workers .lock() - .map_err(|_| ApplicationError::Poisoned)?[slot] = Some(worker) + .map_err(|_| ApplicationError::Poisoned)?[ticket.index] = Some(worker) } - Err(cause) => { - // The worker thread never ran. Release the slot and keep the - // same bounded operator-visible record as a failed worker. - let failure = ConnectionFailure { - slot, - received: None, - original: None, - cause: ApplicationError::Io(cause), - fence_error: None, - diagnostic_error: None, - }; - let finished = { - let mut state = - self.state.lock().map_err(|_| ApplicationError::Poisoned)?; - let finished = state.slots.finish(slot, Err(failure), Instant::now()); - self.changed.notify_all(); - finished - }; - match finished { - Finished::Retained(record) => { - let _ = writeln!(std::io::stderr().lock(), "{record}"); - } - Finished::Released(failure) => { - let _ = writeln!(std::io::stderr().lock(), "{failure:?}"); - } - Finished::Clean => {} - } + Err(_cause) => { + // Spawning dropped the closure, so the guard's `Drop` + // already released the slot and recorded the failure. } } } } - fn connection(&self, stream: TcpStream, slot: usize) -> Result<(), ConnectionFailure> { + + /// A bounded owner label for one worker's retained record. + fn owner_label(&self, ticket: SlotTicket) -> String { + format!( + "{:02x}{:02x}{:02x}{:02x}:{}:layerfs-control-{}", + self.instance[0], + self.instance[1], + self.instance[2], + self.instance[3], + std::process::id(), + ticket.index + ) + } + fn connection(&self, stream: TcpStream, ticket: SlotTicket) -> Result<(), ConnectionFailure> { + let slot = ticket.index; let timeout = Some(Duration::from_millis(u64::from( self.setup.limits.handshake_ms, ))); @@ -212,7 +348,7 @@ impl Application { } let session_end = matches!(call.request, Request::EndSession) && outcome.is_ok(); - let reserved_refusal = slot == usize::from(self.setup.limits.connections) + let reserved_refusal = ticket.class == SlotClass::Reserved && matches!( &outcome, Err(crate::control::Failure::Rejected( @@ -357,7 +493,7 @@ impl Application { ) -> Result { use crate::control::Failure; use layerfs_bridge::control::SdkValue; - let (vacant, running) = self.connection_slots().map_err(|_| Failure::Poisoned)?; + let counts = self.connection_slots().map_err(|_| Failure::Poisoned)?; let snapshot = self .retained_connection_failures() .map_err(|_| Failure::Poisoned)?; @@ -367,6 +503,9 @@ impl Application { .map(|failure| { SdkValue::map([ ("slot", SdkValue::Int(failure.slot as i64)), + ("class", SdkValue::text(failure.class)), + ("generation", SdkValue::Int(failure.generation as i64)), + ("owner", SdkValue::text(&failure.owner)), ( "received_bytes", failure @@ -394,6 +533,10 @@ impl Application { .map_or(SdkValue::Null, SdkValue::text), ), ("age_ms", SdkValue::Int(failure.age.as_millis() as i64)), + ( + "expires_in_ms", + SdkValue::Int(failure.expires_in.as_millis() as i64), + ), ]) }) .collect(); @@ -401,14 +544,29 @@ impl Application { ( "admission", SdkValue::map([ - ("vacant", SdkValue::Int(vacant as i64)), - ("running", SdkValue::Int(running as i64)), + ("pool_vacant", SdkValue::Int(counts.pool_vacant as i64)), + ("pool_running", SdkValue::Int(counts.pool_running as i64)), + ( + "reserved_vacant", + SdkValue::Int(counts.reserved_vacant as i64), + ), + ( + "reserved_running", + SdkValue::Int(counts.reserved_running as i64), + ), + ]), + ), + ( + "retained", + SdkValue::map([ + ("limit", SdkValue::Int(snapshot.limit as i64)), + ("ttl_ms", SdkValue::Int(snapshot.ttl.as_millis() as i64)), + ("count", SdkValue::Int(snapshot.failures.len() as i64)), + ("dropped", SdkValue::Int(snapshot.dropped as i64)), + ("recorded", SdkValue::Int(snapshot.recorded as i64)), + ("failures", SdkValue::List(failures)), ]), ), - ("limit", SdkValue::Int(snapshot.limit as i64)), - ("ttl_ms", SdkValue::Int(snapshot.ttl.as_millis() as i64)), - ("dropped", SdkValue::Int(snapshot.dropped as i64)), - ("failures", SdkValue::List(failures)), ])) } } @@ -566,10 +724,10 @@ mod tests { .map(|snapshot| snapshot.failures.len() == round + 1) .unwrap_or(false) }); - let (vacant, _) = application.connection_slots().unwrap(); + let counts = application.connection_slots().unwrap(); assert!( - vacant > 0, - "round {round}: a retained failure consumed the last slot" + counts.pool_vacant > 0, + "round {round}: a retained failure consumed the last pool slot" ); } @@ -577,13 +735,17 @@ mod tests { assert_eq!(snapshot.failures.len(), rounds); assert!(snapshot.dropped <= 1); let operator = application.connection_failures().unwrap(); - assert_eq!(operator.get_int("limit"), Some(64)); + let retained = operator.get("retained").unwrap(); + assert_eq!(retained.get_int("limit"), Some(64)); + assert_eq!(retained.get_int("recorded"), Some(rounds as i64)); assert_eq!( - operator.get("admission").and_then(|v| v.get_int("vacant")), - Some(usize::from(CONNECTIONS + 1) as i64) + operator + .get("admission") + .and_then(|v| v.get_int("pool_vacant")), + Some(usize::from(CONNECTIONS) as i64) ); assert_eq!( - operator.get("failures").map(|v| match v { + retained.get("failures").map(|v| match v { layerfs_bridge::control::SdkValue::List(items) => items.len(), _ => 0, }), @@ -592,6 +754,13 @@ mod tests { let record = &snapshot.failures[0]; assert_eq!(record.slot, 0); + assert_eq!(record.class, "pool"); + assert!(record.generation > 0); + assert!( + record.owner.contains("layerfs-control-0"), + "{}", + record.owner + ); assert!(record.received_bytes.is_some()); assert!(record.cause.contains("kernel request"), "{}", record.cause); assert!(!record.reply_sent); @@ -613,4 +782,174 @@ mod tests { } drop(connection); } + + /// The guard is the spawn-failure/panic path: dropping it without an + /// explicit finish releases the slot and records exactly once. + #[test] + fn dropping_the_guard_releases_the_slot_and_records_once() { + let directory = temp_directory("guard"); + let application = application(&directory); + let ticket = { + let mut state = application.state.lock().unwrap(); + state.slots.admit(AdmissionClass::ControlPool).unwrap() + }; + { + let _guard = SlotGuard { + application: application.clone(), + ticket, + owner: "test:pid:layerfs-control-0".to_owned(), + done: false, + }; + // dropped here without an explicit finish + } + let counts = application.connection_slots().unwrap(); + assert_eq!(counts.pool_running, 0); + assert_eq!(counts.pool_vacant, usize::from(CONNECTIONS)); + let snapshot = application.retained_connection_failures().unwrap(); + assert_eq!(snapshot.failures.len(), 1); + assert_eq!(snapshot.failures[0].slot, ticket.index); + assert!( + snapshot.failures[0].cause.contains("dropped"), + "{}", + snapshot.failures[0].cause + ); + } + + /// With every slot held, the accept loop writes the advisory notice the + /// client classifies instead of a bare EOF (#540). + #[test] + fn no_vacant_slot_writes_the_capacity_notice() { + let directory = temp_directory("notice"); + let application = application(&directory); + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let address = listener.local_addr().unwrap(); + let serving = application.clone(); + std::thread::spawn(move || { + let _ = serving.serve(listener); + }); + let tickets = { + let mut state = application.state.lock().unwrap(); + let mut tickets = (0..CONNECTIONS) + .map(|_| state.slots.admit(AdmissionClass::ControlPool).unwrap()) + .collect::>(); + tickets.push(state.slots.admit(AdmissionClass::Install).unwrap()); + tickets + }; + let stream = TcpStream::connect_timeout(&address, Duration::from_secs(2)).unwrap(); + stream + .set_read_timeout(Some(Duration::from_secs(2))) + .unwrap(); + stream + .set_write_timeout(Some(Duration::from_secs(2))) + .unwrap(); + let error = match transport::initiate( + stream, + &CLIENT_PRIVATE, + layerfs_bridge::duplex::public_key(&SERVER_PRIVATE).unwrap(), + ) { + Ok(_) => panic!("a full daemon admitted a connection"), + Err(error) => error, + }; + match error { + transport::ChannelError::Admission(notice) => { + assert_eq!( + notice.reason, + layerfs_bridge::duplex::admission::AdmissionReason::Starting + ); + assert_eq!(notice.pool_vacant, 0); + assert_eq!(notice.reserved_vacant, 0); + } + other => panic!("expected a capacity notice, got {other:?}"), + } + let mut state = application.state.lock().unwrap(); + for ticket in tickets { + state.slots.finish(ticket, Ok(()), None, Instant::now()); + } + } + + /// Sixteen concurrent failures finish without deadlock or leak, and a + /// new authenticated connection is admitted afterwards. + #[test] + fn concurrent_failures_do_not_deadlock_or_leak() { + let directory = temp_directory("concurrent"); + let application = application(&directory); + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let address = listener.local_addr().unwrap(); + let serving = application.clone(); + std::thread::spawn(move || { + let _ = serving.serve(listener); + }); + let mut threads = Vec::new(); + for _ in 0..16 { + threads.push(std::thread::spawn(move || { + for _ in 0..4 { + // Under a real failure storm the pool can be momentarily + // full; admission refusal is precisely non-terminal, so + // retry until this round is admitted. + loop { + let stream = + TcpStream::connect_timeout(&address, Duration::from_secs(2)).unwrap(); + stream + .set_read_timeout(Some(Duration::from_secs(2))) + .unwrap(); + stream + .set_write_timeout(Some(Duration::from_secs(2))) + .unwrap(); + let mut connection = match transport::initiate( + stream, + &CLIENT_PRIVATE, + layerfs_bridge::duplex::public_key(&SERVER_PRIVATE).unwrap(), + ) { + Ok(connection) => connection, + Err(transport::ChannelError::Admission(_)) => { + std::thread::sleep(Duration::from_millis(5)); + continue; + } + Err(error) => panic!("unexpected open failure: {error:?}"), + }; + connection + .send + .send(b"client-died-before-reading-reply") + .unwrap(); + drop(connection); + break; + } + } + })); + } + for thread in threads { + thread.join().unwrap(); + } + until("every concurrent worker to finish", || { + application + .connection_slots() + .map(|counts| counts.pool_running == 0) + .unwrap_or(false) + }); + let counts = application.connection_slots().unwrap(); + assert_eq!(counts.pool_running, 0); + assert_eq!(counts.pool_vacant, usize::from(CONNECTIONS)); + let snapshot = application.retained_connection_failures().unwrap(); + // Some connections die before their first decoded request and are + // released with a log line rather than retained; the invariant is + // that the ring stays bounded and its counters are exact. + assert!(snapshot.failures.len() <= 64); + assert!(snapshot.failures.len() >= 1); + assert_eq!( + snapshot.recorded, + snapshot.failures.len() as u64 + snapshot.dropped + ); + + let mut connection = connect(address); + let hello = Call { + id: 1, + request: Request::Hello(HelloRequest { + expected_instance: Some(application.instance), + wait_for_store: false, + }), + }; + connection.send.send(&hello.encode().unwrap()).unwrap(); + let answer = Answer::decode(connection.receive.receive().unwrap()).unwrap(); + assert!(matches!(answer.reply, Reply::Hello(_))); + } } diff --git a/engine/crates/layerfs-daemon/src/application/failure.rs b/engine/crates/layerfs-daemon/src/application/failure.rs index e824e39731..37e3e7e774 100644 --- a/engine/crates/layerfs-daemon/src/application/failure.rs +++ b/engine/crates/layerfs-daemon/src/application/failure.rs @@ -41,6 +41,8 @@ pub enum ApplicationError { RetainedControl(Box), /// Original install result retained after application publication synchronization failed. InstallPublication(Box>>), + /// A connection worker panicked or was dropped before it could finish. + Worker(String), /// Actual application state synchronization failed; ownership remains held. Poisoned, } @@ -62,6 +64,7 @@ impl fmt::Display for ApplicationError { Self::InstallPublication(_) => { f.write_str("original install result retained; application publication poisoned") } + Self::Worker(message) => write!(f, "connection worker: {message}"), Self::Poisoned => f.write_str("application state poisoned; original custody retained"), } } diff --git a/engine/crates/layerfs-daemon/src/application/owner.rs b/engine/crates/layerfs-daemon/src/application/owner.rs index 55f4711c6c..d50f11f664 100644 --- a/engine/crates/layerfs-daemon/src/application/owner.rs +++ b/engine/crates/layerfs-daemon/src/application/owner.rs @@ -23,9 +23,64 @@ use std::{ time::Instant, }; -pub(super) enum Slot { +/// Slots reserved for the installer (and, later, a presence lease); ordinary +/// controls never consume them. +pub(super) const RESERVED_SLOTS: usize = 1; + +/// The fixed class of one slot index. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(super) enum SlotClass { + /// Ordinary authenticated control connections. + Pool, + /// Installer today, a presence lease later. + Reserved, +} + +impl SlotClass { + pub(super) fn as_str(self) -> &'static str { + match self { + Self::Pool => "pool", + Self::Reserved => "reserved", + } + } +} + +/// What a caller is admitted for; maps to the slot class it may use. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(super) enum AdmissionClass { + /// An ordinary control connection. + ControlPool, + /// The one-time Store installer. + Install, + /// A future presence lease. + #[allow(dead_code)] + Lease, +} + +impl AdmissionClass { + fn slot_class(self) -> SlotClass { + match self { + Self::ControlPool => SlotClass::Pool, + Self::Install | Self::Lease => SlotClass::Reserved, + } + } +} + +/// One admission slot: free, or running one worker generation. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(super) enum SlotState { Vacant, - Running, + Running { generation: u64, class: SlotClass }, +} + +/// Proof that one admission owns a slot and generation. Every path ends in +/// exactly one `Slots::finish` with this ticket; a stale ticket changes +/// nothing, so a duplicate or late finish cannot free a newer worker. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub(super) struct SlotTicket { + pub(super) index: usize, + pub(super) generation: u64, + pub(super) class: SlotClass, } /// What finishing one connection did with its failure, if any. @@ -36,54 +91,105 @@ pub(super) enum Finished { Released(Box), /// The failure was recorded in the bounded store; its slot is already free. Retained(RetainedFailure), + /// A stale or duplicate finish: nothing changed. + Stale, +} + +/// Admission counts by class. +#[derive(Clone, Copy, Debug, Eq, PartialEq)] +pub struct SlotCounts { + pub pool_vacant: usize, + pub pool_running: usize, + pub reserved_vacant: usize, + pub reserved_running: usize, } /// The fixed control-slot table and the bounded retained-failure store beside it. /// /// A retained failure never owns a slot: `finish` always leaves it `Vacant` /// and only records the failure. Admission capacity therefore cannot leak -/// (#540). +/// (#540). The layout is `connections` `Pool` entries followed by +/// [`RESERVED_SLOTS`] `Reserved` entries; a class only ever admits within its +/// own range. pub(super) struct Slots { - slots: Vec, + slots: Vec, + pool: usize, + next_generation: u64, retained: RetainedFailures, } impl Slots { pub(super) fn new(count: usize) -> Self { + let pool = count.saturating_sub(RESERVED_SLOTS); + let mut slots = Vec::with_capacity(pool + RESERVED_SLOTS); + slots.resize(pool, SlotState::Vacant); + slots.resize(pool + RESERVED_SLOTS, SlotState::Vacant); Self { - slots: (0..count).map(|_| Slot::Vacant).collect(), + slots, + pool, + next_generation: 0, retained: RetainedFailures::default(), } } - /// Claims one vacant slot, marking it `Running`, or `None` when every - /// slot is in use. - pub(super) fn admit(&mut self) -> Option { - let slot = self - .slots - .iter() - .position(|value| matches!(value, Slot::Vacant))?; - self.slots[slot] = Slot::Running; - Some(slot) + fn class_of(&self, index: usize) -> SlotClass { + if index < self.pool { + SlotClass::Pool + } else { + SlotClass::Reserved + } + } + + /// Claims one vacant slot of `class`, or `None` when that class is full. + /// A pool admission never takes a reserved slot and vice versa. + pub(super) fn admit(&mut self, class: AdmissionClass) -> Option { + let wanted = class.slot_class(); + let index = self.slots.iter().enumerate().find_map(|(index, value)| { + (self.class_of(index) == wanted && matches!(value, SlotState::Vacant)).then_some(index) + })?; + self.generation_ticket(index, wanted) + } + + fn generation_ticket(&mut self, index: usize, class: SlotClass) -> Option { + self.next_generation = self.next_generation.saturating_add(1); + let generation = self.next_generation; + *self.slots.get_mut(index)? = SlotState::Running { generation, class }; + Some(SlotTicket { + index, + generation, + class, + }) } - /// Ends one worker: release its slot and, for a retained failure, record it. + /// Ends one worker: release its slot and, for a retained failure, record + /// the already-built record. A ticket whose generation or class no longer + /// matches changes nothing. pub(super) fn finish( &mut self, - slot: usize, + ticket: SlotTicket, result: Result<(), ConnectionFailure>, + prebuilt: Option, now: Instant, ) -> Finished { - let Some(current) = self.slots.get_mut(slot) else { - return Finished::Clean; - }; - *current = Slot::Vacant; + let running = matches!( + self.slots.get(ticket.index), + Some(SlotState::Running { generation, class }) + if *generation == ticket.generation && *class == ticket.class + ); + if !running { + return Finished::Stale; + } + self.slots[ticket.index] = SlotState::Vacant; match result { Ok(()) => Finished::Clean, Err(failure) if releases_after_logging(&failure) => { Finished::Released(Box::new(failure)) } - Err(failure) => Finished::Retained(self.retained.record(&failure, now)), + Err(_) => { + let record = prebuilt.expect("a retained failure is described before the lock"); + let record = self.retained.record(record, now); + Finished::Retained(record) + } } } @@ -91,14 +197,33 @@ impl Slots { self.retained.snapshot(now) } - /// Vacant and running (in-use) slots. - pub(super) fn counts(&self) -> (usize, usize) { - let vacant = self - .slots - .iter() - .filter(|value| matches!(value, Slot::Vacant)) - .count(); - (vacant, self.slots.len() - vacant) + /// Admission counts for each class. + pub(super) fn counts(&self) -> SlotCounts { + let mut counts = SlotCounts { + pool_vacant: 0, + pool_running: 0, + reserved_vacant: 0, + reserved_running: 0, + }; + for (index, value) in self.slots.iter().enumerate() { + match (self.class_of(index), value) { + (SlotClass::Pool, SlotState::Vacant) => counts.pool_vacant += 1, + (SlotClass::Pool, SlotState::Running { .. }) => counts.pool_running += 1, + (SlotClass::Reserved, SlotState::Vacant) => counts.reserved_vacant += 1, + (SlotClass::Reserved, SlotState::Running { .. }) => counts.reserved_running += 1, + } + } + counts + } + + /// Visible retained records, for the admission notice. + pub(super) fn visible(&mut self) -> usize { + self.retained.len() + } + + /// Drops expired records; the accept loop reaps when it refuses admission. + pub(super) fn reap(&mut self, now: Instant) { + self.retained.reap(now); } } @@ -363,8 +488,8 @@ impl Application { Ok(state.slots.snapshot(Instant::now())) } - /// Vacant and in-use control slots. - pub fn connection_slots(&self) -> Result<(usize, usize), ApplicationError> { + /// Vacant and in-use control slots, by class. + pub fn connection_slots(&self) -> Result { let state = self.state.lock().map_err(|_| ApplicationError::Poisoned)?; Ok(state.slots.counts()) } @@ -382,3 +507,124 @@ fn postgres(url: &str, schema: &str, synchronous_commit: &str) -> PostgresSelect }; PostgresSelection::new(url.to_string(), schema.to_string()).with_synchronous_commit(setting) } + +#[cfg(test)] +mod tests { + use super::*; + use crate::application::retained::{RetainedFailure, TTL}; + use std::time::Duration; + + fn retained_failure(slot: usize) -> ConnectionFailure { + ConnectionFailure { + slot, + received: None, + original: None, + cause: ApplicationError::Poisoned, + fence_error: None, + diagnostic_error: None, + } + } + + fn describe(slot: usize, class: SlotClass, generation: u64) -> RetainedFailure { + RetainedFailure::describe( + &retained_failure(slot), + class, + generation, + "daemon:pid:layerfs-control-0", + ) + } + + #[test] + fn admit_uses_only_its_class() { + let mut slots = Slots::new(8 + RESERVED_SLOTS); + for _ in 0..8 { + slots.admit(AdmissionClass::ControlPool).unwrap(); + } + assert_eq!( + slots.admit(AdmissionClass::ControlPool), + None, + "a pool admission took the reserved slot" + ); + let reserved = slots.admit(AdmissionClass::Install).unwrap(); + assert_eq!(reserved.index, 8); + assert_eq!(reserved.class, SlotClass::Reserved); + assert_eq!(slots.admit(AdmissionClass::Lease), None); + let counts = slots.counts(); + assert_eq!(counts.pool_vacant, 0); + assert_eq!(counts.pool_running, 8); + assert_eq!(counts.reserved_vacant, 0); + assert_eq!(counts.reserved_running, 1); + } + + #[test] + fn finish_frees_even_for_retained_failure() { + let mut slots = Slots::new(8 + RESERVED_SLOTS); + let now = Instant::now(); + let ticket = slots.admit(AdmissionClass::ControlPool).unwrap(); + let prebuilt = describe(ticket.index, ticket.class, ticket.generation); + match slots.finish( + ticket, + Err(retained_failure(ticket.index)), + Some(prebuilt), + now, + ) { + Finished::Retained(record) => { + assert_eq!(record.class, "pool"); + assert_eq!(record.generation, ticket.generation); + } + _ => panic!("a decoded failure was not retained"), + } + assert_eq!(slots.counts().pool_vacant, 8); + assert_eq!(slots.snapshot(now).failures.len(), 1); + } + + #[test] + fn stale_or_duplicate_finish_is_ignored() { + let mut slots = Slots::new(8 + RESERVED_SLOTS); + let now = Instant::now(); + let first = slots.admit(AdmissionClass::ControlPool).unwrap(); + slots.finish( + first, + Err(retained_failure(first.index)), + Some(describe(first.index, first.class, first.generation)), + now, + ); + // A duplicate finish of the same ticket changes nothing. + assert!(matches!( + slots.finish(first, Ok(()), None, now), + Finished::Stale + )); + let second = slots.admit(AdmissionClass::ControlPool).unwrap(); + assert_eq!(second.index, first.index); + assert!(second.generation > first.generation); + // The old ticket cannot free the newer worker. + assert!(matches!( + slots.finish(first, Ok(()), None, now), + Finished::Stale + )); + assert_eq!(slots.counts().pool_running, 1); + slots.finish(second, Ok(()), None, now); + assert_eq!(slots.counts().pool_vacant, 8); + } + + #[test] + fn retained_store_reaps_expired_records() { + let mut slots = Slots::new(1 + RESERVED_SLOTS); + let now = Instant::now(); + let ticket = slots.admit(AdmissionClass::ControlPool).unwrap(); + slots.finish( + ticket, + Err(retained_failure(ticket.index)), + Some(describe(ticket.index, ticket.class, ticket.generation)), + now, + ); + slots.retained.reap(now + TTL + Duration::from_secs(1)); + assert_eq!( + slots + .snapshot(now + TTL + Duration::from_secs(1)) + .failures + .len(), + 0 + ); + } +} diff --git a/engine/crates/layerfs-daemon/src/application/retained.rs b/engine/crates/layerfs-daemon/src/application/retained.rs index 613548eedd..c6c39e0dc3 100644 --- a/engine/crates/layerfs-daemon/src/application/retained.rs +++ b/engine/crates/layerfs-daemon/src/application/retained.rs @@ -4,7 +4,7 @@ //! an explicit transfer that no product path ever made. That cost one of the //! daemon's fixed control slots per failure until every new connection was //! refused (#540). The slot is now released at once; what survives here is a -//! compact, bounded record with its exact deciding cause. +//! compact, bounded, owned and timed record with its exact deciding cause. use super::{ApplicationError, ConnectionFailure}; use std::{ collections::VecDeque, @@ -24,6 +24,13 @@ const CAUSE_BYTES: usize = 512; pub struct RetainedFailure { /// Slot the failed worker occupied; it is already free for a new connection. pub slot: usize, + /// `pool` or `reserved`: the class of the slot that was released. + pub class: &'static str, + /// Admission generation of the released worker; a stale finish never frees + /// a newer one. + pub generation: u64, + /// The worker that failed: daemon instance, pid and thread. + pub owner: String, /// Bytes of a request that failed decoding, when one was received. pub received_bytes: Option, /// `control` or `install` when a request was decoded, else `None`. @@ -38,18 +45,62 @@ pub struct RetainedFailure { pub diagnostic_error: Option, /// Age at the observation that returned this record. pub age: Duration, + /// Remaining lifetime at the observation that returned this record. + pub expires_in: Duration, + /// Visible records at the moment this one was recorded. + pub retained: usize, + /// Configured record limit at the moment this one was recorded. + pub limit: usize, +} + +impl RetainedFailure { + /// The bounded record for `failure`, built outside the state lock. + pub(super) fn describe( + failure: &ConnectionFailure, + class: super::owner::SlotClass, + generation: u64, + owner: &str, + ) -> Self { + Self { + slot: failure.slot, + class: class.as_str(), + generation, + owner: owner.to_owned(), + received_bytes: failure.received.as_ref().map(Vec::len), + request: request_kind(failure), + reply_sent: reply_sent(failure), + cause: bounded(&failure.cause.to_string()), + fence_error: failure + .fence_error + .as_ref() + .map(|error| bounded(&error.to_string())), + diagnostic_error: failure + .diagnostic_error + .as_ref() + .map(|error| bounded(&error.to_string())), + age: Duration::ZERO, + expires_in: TTL, + retained: 0, + limit: LIMIT, + } + } } impl fmt::Display for RetainedFailure { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { f.debug_struct("ConnectionFailure") .field("slot", &self.slot) + .field("class", &self.class) + .field("generation", &self.generation) .field("received_bytes", &self.received_bytes) .field("original_kind", &self.request) .field("reply", &if self.reply_sent { "sent" } else { "not_sent" }) .field("cause", &self.cause) .field("fence_error", &self.fence_error) .field("diagnostic_error", &self.diagnostic_error) + .field("retained", &format!("{}/{}", self.retained, self.limit)) + .field("owner", &self.owner) + .field("expires_in_ms", &self.expires_in.as_millis()) .finish() } } @@ -61,6 +112,8 @@ pub struct RetainedSnapshot { pub failures: Vec, /// Records evicted by the limit or the TTL since startup. pub dropped: u64, + /// Total records ever recorded since startup. + pub recorded: u64, /// Configured record limit. pub limit: usize, /// Configured record TTL. @@ -70,12 +123,16 @@ pub struct RetainedSnapshot { struct Entry { record: RetainedFailure, at: Instant, + deadline: Instant, } -/// A fixed-capacity, TTL-pruned ring of retained connection failures. +/// A fixed-capacity, TTL-pruned ring of retained connection failures. Its +/// capacity is reserved when it is built, so recording under the state lock +/// never allocates. pub(super) struct RetainedFailures { entries: VecDeque, dropped: u64, + recorded: u64, limit: usize, ttl: Duration, } @@ -88,34 +145,41 @@ impl Default for RetainedFailures { impl RetainedFailures { pub(super) fn new(limit: usize, ttl: Duration) -> Self { + let limit = limit.max(1); Self { - entries: VecDeque::new(), + entries: VecDeque::with_capacity(limit), dropped: 0, - limit: limit.max(1), + recorded: 0, + limit, ttl, } } - /// Records one failure, prunes expired records and evicts the oldest - /// beyond the limit. Returns the exact record that now is visible. - pub(super) fn record(&mut self, failure: &ConnectionFailure, now: Instant) -> RetainedFailure { + /// Records one already-described failure, prunes expired records and + /// evicts the oldest beyond the limit. Returns the exact record that now + /// is visible, with its store position filled in. + pub(super) fn record(&mut self, mut record: RetainedFailure, now: Instant) -> RetainedFailure { self.prune(now); while self.entries.len() >= self.limit { self.entries.pop_front(); self.dropped = self.dropped.saturating_add(1); } - let record = describe(failure); + record.retained = self.entries.len() + 1; + record.limit = self.limit; + record.expires_in = self.ttl; self.entries.push_back(Entry { record: record.clone(), at: now, + deadline: now + self.ttl, }); + self.recorded = self.recorded.saturating_add(1); record } - /// Drops records older than the TTL; a stale record is never returned. + /// Drops records whose deadline passed; a stale record is never returned. pub(super) fn prune(&mut self, now: Instant) { while let Some(front) = self.entries.front() { - if now.saturating_duration_since(front.at) < self.ttl { + if now < front.deadline { break; } self.entries.pop_front(); @@ -123,6 +187,11 @@ impl RetainedFailures { } } + /// The lazy reaper: the accept loop calls it when it refuses admission. + pub(super) fn reap(&mut self, now: Instant) { + self.prune(now); + } + /// A copy of the visible records, oldest first, with their ages. pub(super) fn snapshot(&mut self, now: Instant) -> RetainedSnapshot { self.prune(now); @@ -133,42 +202,22 @@ impl RetainedFailures { .map(|entry| { let mut record = entry.record.clone(); record.age = now.saturating_duration_since(entry.at); + record.expires_in = self.ttl.saturating_sub(record.age); record }) .collect(), dropped: self.dropped, + recorded: self.recorded, limit: self.limit, ttl: self.ttl, } } - #[cfg(test)] pub(super) fn len(&self) -> usize { self.entries.len() } } -fn describe(failure: &ConnectionFailure) -> RetainedFailure { - let request = request_kind(failure); - let reply_sent = reply_sent(failure); - RetainedFailure { - slot: failure.slot, - received_bytes: failure.received.as_ref().map(Vec::len), - request, - reply_sent, - cause: bounded(&failure.cause.to_string()), - fence_error: failure - .fence_error - .as_ref() - .map(|error| bounded(&error.to_string())), - diagnostic_error: failure - .diagnostic_error - .as_ref() - .map(|error| bounded(&error.to_string())), - age: Duration::ZERO, - } -} - /// Whether a request was decoded, from the direct field or the cause that /// owns the original receipt. fn request_kind(failure: &ConnectionFailure) -> Option<&'static str> { @@ -233,13 +282,14 @@ fn bounded(text: &str) -> String { #[cfg(test)] mod tests { use super::*; + use crate::application::owner::SlotClass; use crate::control::{Served, Success}; use layerfs_bridge::control::{Call, Reply, Request}; use layerfs_bridge::duplex::{ChannelError, ChannelWork, PeerEndFailure, PeerEndPhase}; /// A failure after the daemon sent EndSession's reply: what a client that /// dies before reading it leaves behind. - fn retained_after_reply(slot: usize) -> ConnectionFailure { + fn retained_after_reply(slot: usize, _generation: u64) -> ConnectionFailure { ConnectionFailure { slot, received: None, @@ -265,16 +315,26 @@ mod tests { } } + fn describe(slot: usize, generation: u64) -> RetainedFailure { + RetainedFailure::describe( + &retained_after_reply(slot, generation), + SlotClass::Pool, + generation, + "a1b2c3d4:812:layerfs-control-0", + ) + } + #[test] fn limit_evicts_oldest_and_counts_drops() { let mut store = RetainedFailures::new(3, TTL); let now = Instant::now(); for slot in 0..5 { - store.record(&retained_after_reply(slot), now); + store.record(describe(slot, slot as u64), now); } assert_eq!(store.len(), 3); let snapshot = store.snapshot(now); assert_eq!(snapshot.dropped, 2); + assert_eq!(snapshot.recorded, 5); assert_eq!( snapshot.failures.iter().map(|f| f.slot).collect::>(), vec![2, 3, 4] @@ -287,20 +347,46 @@ mod tests { fn ttl_prunes_expired_records() { let mut store = RetainedFailures::new(8, Duration::from_secs(10)); let now = Instant::now(); - store.record(&retained_after_reply(1), now); - store.record(&retained_after_reply(2), now + Duration::from_secs(5)); + store.record(describe(1, 1), now); + store.record(describe(2, 2), now + Duration::from_secs(5)); let snapshot = store.snapshot(now + Duration::from_secs(9)); assert_eq!(snapshot.failures.len(), 2); + assert_eq!(snapshot.failures[0].expires_in, Duration::from_secs(1)); let snapshot = store.snapshot(now + Duration::from_secs(16)); assert_eq!(snapshot.failures.len(), 0); assert_eq!(snapshot.dropped, 2); } + #[test] + fn cause_is_bounded_and_char_safe() { + let long = "é".repeat(4096); + let bounded = bounded(&long); + assert!(bounded.len() <= CAUSE_BYTES + "…".len()); + assert!(bounded.ends_with('…')); + assert!(bounded.is_char_boundary(bounded.len())); + } + + #[test] + fn owner_and_deadline_are_visible() { + let mut store = RetainedFailures::new(8, TTL); + let now = Instant::now(); + let record = store.record(describe(3, 9), now); + assert_eq!(record.class, "pool"); + assert_eq!(record.generation, 9); + assert!(record.owner.contains("812"), "{}", record.owner); + assert_eq!(record.retained, 1); + let snapshot = store.snapshot(now + Duration::from_secs(1)); + assert_eq!( + snapshot.failures[0].expires_in, + TTL - Duration::from_secs(1) + ); + } + #[test] fn record_names_the_cause_request_and_reply_state() { let mut store = RetainedFailures::new(8, TTL); let now = Instant::now(); - let record = store.record(&retained_after_reply(3), now); + let record = store.record(describe(3, 1), now); assert_eq!(record.slot, 3); assert_eq!(record.request, Some("end-session")); assert!(record.reply_sent); @@ -312,5 +398,8 @@ mod tests { "{line}" ); assert!(line.contains("reply: \"sent\""), "{line}"); + assert!(line.contains("class: \"pool\""), "{line}"); + assert!(line.contains("owner:"), "{line}"); + assert!(line.contains("expires_in_ms:"), "{line}"); } } From 52f9c16668df3ce9e7599d8807de265bcd3fb87e Mon Sep 17 00:00:00 2001 From: rain Date: Wed, 4 Nov 2026 13:22:31 +0800 Subject: [PATCH 03/18] fix(control): bound sandbox.get's capacity query to 2s (#540) The new best-effort daemon capacity read model must not inherit the ordinary 60 s admission wait, or sandbox.get itself could stall behind a refusing daemon. It now uses a 2 s control wait; product calls keep the ordinary wait. --- .../layerfs-control/src/sandbox/dispatch.rs | 26 +++++++++++++++---- 1 file changed, 21 insertions(+), 5 deletions(-) diff --git a/api/crates/layerfs-control/src/sandbox/dispatch.rs b/api/crates/layerfs-control/src/sandbox/dispatch.rs index d4b0003614..e838760f5e 100644 --- a/api/crates/layerfs-control/src/sandbox/dispatch.rs +++ b/api/crates/layerfs-control/src/sandbox/dispatch.rs @@ -98,11 +98,22 @@ fn daemon_backend(op: &str, args: SdkValue) -> Outcome { ), other => other, }; - let answer = crate::daemon::operator::call( - &mut *crate::common::trace::control(&state.controls)?, - op, - args, - ); + // The capacity read model is a best-effort diagnostic: bound its + // admission wait so a refusing daemon cannot delay `sandbox.get` by the + // ordinary 60 s. The product calls above keep the ordinary wait. + let answer = if op == CAPACITY_QUERY { + crate::daemon::operator::call( + &mut *crate::common::trace::control_within(&state.controls, CAPACITY_WAIT)?, + op, + args, + ) + } else { + crate::daemon::operator::call( + &mut *crate::common::trace::control(&state.controls)?, + op, + args, + ) + }; answer.map_err(|error| match error { crate::SdkError::Refused(refusal) => refusal, crate::SdkError::Operation(failure) => { @@ -112,6 +123,11 @@ fn daemon_backend(op: &str, args: SdkValue) -> Outcome { }) } +/// The daemon's control-capacity/retained-failure read model (#540). +const CAPACITY_QUERY: &str = "backend.daemon.connection_failures"; +/// How long a best-effort capacity read waits for control admission. +const CAPACITY_WAIT: std::time::Duration = std::time::Duration::from_secs(2); + /// Runs the Workspace status read once. pub fn backend(op: String, args: SdkValue) -> Outcome { match op.as_str() { From c9457e3d445e199cc179bb4ba773e7be02b8f22f Mon Sep 17 00:00:00 2001 From: rain Date: Wed, 4 Nov 2026 15:16:09 +0800 Subject: [PATCH 04/18] feat(control): query live daemon capacity in doctor (#540) The doctor now asks each running Sandbox whose daemon endpoint its record or control.json names for the same backend.daemon.connection_failures read model sandbox.get exposes as daemon_capacity. The query is best-effort and strictly bounded to 2 s (connect, Noise Hello and one exchange), reuses Dial::open_within, and runs under a hard wall so an endpoint that accepts and stalls cannot hold the doctor. A daemon that does not answer is a warning naming its endpoint and the operation, never an error: the doctor stays read-only and does not fail on an idle or stopped daemon, and it starts no machine or Sandbox. An admission-capacity refusal is reported as Capacity on resource daemon_control_slot with its vacant-slot counts; a successful model adds warnings for retained connection failures (count of limit, dropped) and for a pool with no vacant control slot (pool_vacant/running), pointing at backend.daemon.connection_failures. Tests: layerfs-control --lib doctor 3 passed; --test doctor 6 passed (stalled endpoint bounded in ~2 s, no home writes, no endpoint means no query); layerfs-cli --test doctor 2 passed. --- api/crates/layerfs-control/src/daemon/pool.rs | 38 +++ .../layerfs-control/src/doctor/capacity.rs | 299 ++++++++++++++++++ api/crates/layerfs-control/src/doctor/mod.rs | 4 +- .../layerfs-control/src/doctor/report.rs | 3 +- api/crates/layerfs-control/tests/doctor.rs | 102 ++++++ 5 files changed, 444 insertions(+), 2 deletions(-) create mode 100644 api/crates/layerfs-control/src/doctor/capacity.rs diff --git a/api/crates/layerfs-control/src/daemon/pool.rs b/api/crates/layerfs-control/src/daemon/pool.rs index 75b1993d2f..c9064df7a9 100644 --- a/api/crates/layerfs-control/src/daemon/pool.rs +++ b/api/crates/layerfs-control/src/daemon/pool.rs @@ -217,6 +217,44 @@ impl Dial { self.open_admitted(ADMISSION_WAIT) } + /// [`Dial::open`] within `within` (#540 doctor): connecting, the + /// handshake and its Hello must finish inside that time, and the + /// connection keeps those I/O waits for the one bounded call made on + /// it. Nothing is retried and no admission wait applies: a daemon that + /// refuses or does not answer is reported as it came. + pub(crate) fn open_within(&self, within: Duration) -> Result { + let deadline = Instant::now() + within; + let remaining = || { + deadline + .saturating_duration_since(Instant::now()) + .max(Duration::from_millis(1)) + }; + let address = + crate::connect_address(self.endpoint, self.host.as_deref()).map_err(failed)?; + let stream = std::net::TcpStream::connect_timeout(&address, remaining()).map_err(failed)?; + stream.set_read_timeout(Some(remaining())).map_err(failed)?; + stream + .set_write_timeout(Some(remaining())) + .map_err(failed)?; + let connection = match initiate_observed(stream, &self.secret, self.peer).result { + Ok(connection) => connection, + Err(ChannelError::Admission(notice)) => return Err(notice_refusal(notice)), + Err(error) => return Err(failed(error)), + }; + // the waits stay: the caller makes exactly one call and drops it + let mut control = Control::new(connection); + match control + .call(Request::Hello(HelloRequest { + expected_instance: Some(self.instance), + wait_for_store: false, + })) + .map_err(failed)? + { + Reply::Hello(status) if status.phase == DaemonPhase::ControlReady => Ok(control), + _ => Err(refused("StaleSandbox", "saved daemon is not ControlReady")), + } + } + /// [`Dial::open_waiting`], waiting at most `wait`. fn open_admitted(&self, wait: Duration) -> Result { let started = Instant::now(); diff --git a/api/crates/layerfs-control/src/doctor/capacity.rs b/api/crates/layerfs-control/src/doctor/capacity.rs new file mode 100644 index 0000000000..33f5916992 --- /dev/null +++ b/api/crates/layerfs-control/src/doctor/capacity.rs @@ -0,0 +1,299 @@ +//! A running Sandbox's daemon control capacity (#540): the +//! `backend.daemon.connection_failures` read model, queried best-effort for +//! each Sandbox whose record says it runs and whose daemon endpoint is +//! known. Nothing is started: a daemon that does not answer is a warning +//! naming its endpoint and the operation, never an error, because the +//! doctor changes nothing and a stopped daemon is a normal state. +//! Two more warnings come from the model itself: retained connection +//! failures, and a pool with no vacant control slot. +use super::report::Findings; +use super::scan::Scanned; +use crate::common::home::paths; +use crate::common::outcome::{failed, refused}; +use crate::common::secrets; +use crate::daemon::operator; +use crate::sandbox::direct; +use crate::sandbox::record::SandboxRecord; +use layerfs_bridge::control::{SdkRefusal, SdkValue}; +use std::net::SocketAddr; +use std::path::Path; +use std::sync::mpsc; +use std::time::Duration; + +/// The daemon's operator read model of control admission and retained +/// connection failures. +const OPERATION: &str = "backend.daemon.connection_failures"; + +/// How long one daemon query may take: connecting, its Hello and its one +/// exchange. Short on purpose: the doctor must not stall behind a daemon +/// that is unreachable, as an ordinary 60 s admission wait would. +const WAIT: Duration = Duration::from_secs(2); + +/// Queries the daemon of every running Sandbox whose endpoint is known. +pub(super) fn check(home: &Path, scanned: &Scanned, findings: &mut Findings) { + for sandbox in &scanned.sandboxes { + // a Sandbox whose create never recorded an id is gone; a creating, + // closing or unresolved one has no steady daemon to ask + if sandbox.id().is_none() || sandbox.state(false) != "running" { + continue; + } + let name = sandbox.name(); + let Some(endpoint) = endpoint(home, sandbox) else { + // no known endpoint: the record does not say where its daemon + // listens, and the doctor starts nothing to find out + continue; + }; + match probe_bounded(home, sandbox, endpoint) { + Ok(value) => capacity(findings, name, endpoint, &value), + Err(refusal) => unanswered(findings, name, endpoint, &refusal), + } + } +} + +/// The address of a running Sandbox's daemon when its record names one to +/// this host: a forwarded machine's forward, else the endpoint the start +/// recorded in `control.json`. Nothing is observed or started. +fn endpoint(home: &Path, sandbox: &SandboxRecord) -> Option { + if let Some(forward) = (sandbox.to_record().get("daemon")).and_then(direct::forward_of) { + return Some(forward); + } + let keys = secrets::daemon_keys(&paths::sandbox_dir(home, sandbox.name())) + .ok() + .flatten()?; + keys.get_text("endpoint")?.parse().ok() +} + +/// [`probe`] under a hard wall: a daemon that accepts a connection and then +/// says nothing must not hold the doctor past [`WAIT`]. +fn probe_bounded( + home: &Path, + sandbox: &SandboxRecord, + endpoint: SocketAddr, +) -> Result { + let home = home.to_owned(); + let sandbox = sandbox.clone(); + let (sent, received) = mpsc::channel(); + std::thread::spawn(move || { + let _ = sent.send(probe(&home, &sandbox, endpoint)); + }); + match received.recv_timeout(WAIT) { + Ok(result) => result, + Err(_) => Err(refused( + "Unavailable", + format!("the daemon did not answer within {}s", WAIT.as_secs()), + )), + } +} + +/// One daemon query: dial its recorded endpoint with its keys for at most +/// [`WAIT`], then read the capacity model once. +fn probe( + home: &Path, + sandbox: &SandboxRecord, + endpoint: SocketAddr, +) -> Result { + let keys = secrets::daemon_keys(&paths::sandbox_dir(home, sandbox.name()))? + .ok_or_else(|| refused("NoSuchSandbox", "the Sandbox has no daemon keys"))?; + let dial = crate::daemon::pool::Dial { + endpoint, + // a forwarded endpoint is already on this host's loopback + host: None, + secret: secrets::key(&keys, "secret")?, + peer: secrets::key(&keys, "peer")?, + instance: secrets::key(&keys, "instance")?, + }; + let mut control = dial.open_within(WAIT)?; + operator::call(&mut control, OPERATION, SdkValue::Null).map_err(|error| match error { + crate::SdkError::Refused(refusal) => refusal, + crate::SdkError::Operation(failure) => { + crate::daemon::values::refusal(&failure).unwrap_or_else(|| failed(failure)) + } + crate::SdkError::Mount(failure) => failed(failure), + }) +} + +/// A daemon that did not answer: a warning naming its endpoint and the +/// operation. An exhausted pool is reported from the refusal's admission +/// notice, which names its resource and vacant slots; the daemon never +/// admitted the query, so it is still not an error. +fn unanswered(findings: &mut Findings, name: &str, endpoint: SocketAddr, refusal: &SdkRefusal) { + let detail = &refusal.detail; + if refusal.code == "Capacity" && detail.get_text("resource") == Some("daemon_control_slot") { + findings.warning( + ("sandbox", name), + format!( + "Sandbox {name}'s daemon at {endpoint} refused `{OPERATION}` with Capacity on resource daemon_control_slot (pool_vacant {}, reserved_vacant {}, retained {}): no control slot is vacant", + detail.get_int("pool_vacant").unwrap_or(0), + detail.get_int("reserved_vacant").unwrap_or(0), + detail.get_int("retained").unwrap_or(0) + ), + format!( + "end the calls that hold its control slots, or wait for them to end; `layerfs sandbox get {name}` shows the daemon's daemon_capacity, the `{OPERATION}` read model" + ), + ); + return; + } + findings.warning( + ("sandbox", name), + format!( + "Sandbox {name}'s daemon at {endpoint} did not answer `{OPERATION}` within {}s: {}", + WAIT.as_secs(), + refusal.message + ), + format!( + "`layerfs sandbox get {name}` shows whether it still runs; `layerfs sandbox close {name}` closes one whose daemon is gone" + ), + ); +} + +/// The warnings the daemon's capacity model gives: retained connection +/// failures, and a pool with no vacant control slot. +fn capacity(findings: &mut Findings, name: &str, endpoint: SocketAddr, value: &SdkValue) { + let number = |value: &SdkValue, field: &str| value.get_int(field).unwrap_or(0); + if let Some(retained) = value.get("retained") { + let count = number(retained, "count"); + if count > 0 { + findings.warning( + ("sandbox", name), + format!( + "Sandbox {name}'s daemon at {endpoint} retained {count} of {} connection failure record(s) ({} dropped): calls it refused before Hello are kept there for {:.1}s", + number(retained, "limit"), + number(retained, "dropped"), + number(retained, "ttl_ms") as f64 / 1000.0 + ), + format!( + "`layerfs sandbox get {name}` shows the daemon's daemon_capacity, the `{OPERATION}` read model" + ), + ); + } + } + if let Some(admission) = value.get("admission") { + let vacant = number(admission, "pool_vacant"); + let running = number(admission, "pool_running"); + if vacant == 0 && running > 0 { + findings.warning( + ("sandbox", name), + format!( + "Sandbox {name}'s daemon at {endpoint} has no vacant pool control slot (pool_vacant {vacant}, pool_running {running}, reserved_vacant {}, reserved_running {}); a call that needs one is refused Capacity on resource daemon_control_slot", + number(admission, "reserved_vacant"), + number(admission, "reserved_running") + ), + format!( + "end the calls that hold its control slots, or wait for them to end; `layerfs sandbox get {name}` shows the daemon's daemon_capacity, the `{OPERATION}` read model" + ), + ); + } + } +} + +#[cfg(test)] +mod tests { + use super::*; + + fn model( + pool_vacant: i64, + pool_running: i64, + count: i64, + limit: i64, + dropped: i64, + ) -> SdkValue { + SdkValue::map([ + ( + "admission", + SdkValue::map([ + ("pool_vacant", SdkValue::Int(pool_vacant)), + ("pool_running", SdkValue::Int(pool_running)), + ("reserved_vacant", SdkValue::Int(1)), + ("reserved_running", SdkValue::Int(0)), + ]), + ), + ( + "retained", + SdkValue::map([ + ("limit", SdkValue::Int(limit)), + ("ttl_ms", SdkValue::Int(3_600_000)), + ("count", SdkValue::Int(count)), + ("dropped", SdkValue::Int(dropped)), + ("recorded", SdkValue::Int(count)), + ("failures", SdkValue::List(Vec::new())), + ]), + ), + ]) + } + + fn findings(value: &SdkValue) -> SdkValue { + let mut found = Findings::default(); + let endpoint: SocketAddr = "127.0.0.1:1".parse().unwrap(); + capacity(&mut found, "sb", endpoint, value); + found.to_sdk() + } + + #[test] + fn retained_failures_and_an_exhausted_pool_are_warnings_with_their_counts() { + let report = findings(&model(0, 8, 3, 64, 2)); + assert_eq!(report.get("ok"), Some(&SdkValue::Bool(true))); + let SdkValue::List(items) = report.get("findings").unwrap() else { + panic!("no findings"); + }; + assert_eq!(items.len(), 2, "{report:?}"); + let text: Vec = items + .iter() + .map(|item| { + format!( + "{} {}", + item.get_text("message").unwrap(), + item.get_text("fix").unwrap() + ) + }) + .collect(); + assert!(text[0].contains("retained 3 of 64"), "{text:?}"); + assert!(text[0].contains("2 dropped"), "{text:?}"); + assert!(text[0].contains(OPERATION), "{text:?}"); + assert!(text[1].contains("pool_vacant 0"), "{text:?}"); + assert!(text[1].contains("pool_running 8"), "{text:?}"); + assert!(text[1].contains("Capacity"), "{text:?}"); + assert!(text[1].contains("daemon_control_slot"), "{text:?}"); + assert!(text[1].contains(OPERATION), "{text:?}"); + for item in items { + assert_eq!(item.get_text("severity"), Some("warning")); + } + } + + #[test] + fn a_healthy_daemon_gives_no_finding() { + let report = findings(&model(7, 1, 0, 64, 0)); + assert_eq!(report.get("ok"), Some(&SdkValue::Bool(true))); + assert!(matches!(report.get("findings"), Some(SdkValue::List(items)) if items.is_empty())); + } + + #[test] + fn an_exhausted_pool_refusal_is_a_capacity_warning_not_an_error() { + let refusal = SdkRefusal { + code: "Capacity".to_owned(), + message: "the Sandbox's daemon has no vacant control slot".to_owned(), + detail: SdkValue::map([ + ("resource", SdkValue::text("daemon_control_slot")), + ("retained", SdkValue::Int(3)), + ("pool_vacant", SdkValue::Int(0)), + ("reserved_vacant", SdkValue::Int(1)), + ("retryable", SdkValue::Bool(true)), + ]), + }; + let mut found = Findings::default(); + let endpoint: SocketAddr = "127.0.0.1:1".parse().unwrap(); + unanswered(&mut found, "sb", endpoint, &refusal); + let report = found.to_sdk(); + assert_eq!(report.get("ok"), Some(&SdkValue::Bool(true))); + let SdkValue::List(items) = report.get("findings").unwrap() else { + panic!("no findings"); + }; + assert_eq!(items.len(), 1, "{report:?}"); + let message = items[0].get_text("message").unwrap(); + assert!(message.contains("Capacity"), "{message}"); + assert!(message.contains("daemon_control_slot"), "{message}"); + assert!(message.contains("pool_vacant 0"), "{message}"); + assert!(message.contains("reserved_vacant 1"), "{message}"); + assert!(message.contains("retained 3"), "{message}"); + assert_eq!(items[0].get_text("severity"), Some("warning")); + } +} diff --git a/api/crates/layerfs-control/src/doctor/mod.rs b/api/crates/layerfs-control/src/doctor/mod.rs index 3717ec65e3..909724dd47 100644 --- a/api/crates/layerfs-control/src/doctor/mod.rs +++ b/api/crates/layerfs-control/src/doctor/mod.rs @@ -2,9 +2,11 @@ //! changes nothing and starts no machine. It reads the records, their modes //! and references, the `op` intents, the Store leases, a layout 2 home's //! conversion blockers, partial Store copies on `native` and the build of -//! each running machine's worker (its hello alone: no request is sent). +//! each running machine's worker (its hello alone: no request is sent), and +//! a running Sandbox's daemon capacity (a best-effort query, bounded to 2 s). //! Each finding names the call that fixes it. It takes no lock: a home //! that changes meanwhile may be reported as it was part way. +mod capacity; mod checks; mod convert; mod report; diff --git a/api/crates/layerfs-control/src/doctor/report.rs b/api/crates/layerfs-control/src/doctor/report.rs index 7aead1c8ce..2682baa2c4 100644 --- a/api/crates/layerfs-control/src/doctor/report.rs +++ b/api/crates/layerfs-control/src/doctor/report.rs @@ -56,7 +56,7 @@ impl Findings { self.add(Severity::Warning, entity, message, fix); } - fn to_sdk(&self) -> SdkValue { + pub(super) fn to_sdk(&self) -> SdkValue { let ok = !self.0.iter().any(|f| f.severity == Severity::Error); let findings = self.0.iter().map(|finding| { let severity = match finding.severity { @@ -109,6 +109,7 @@ pub fn doctor(home: &Path) -> Outcome { Ok(Layout::Current(_)) => { let scanned = super::scan::scan(home, &mut findings)?; super::checks::check(home, &scanned, &mut findings)?; + super::capacity::check(home, &scanned, &mut findings); super::workers::check(home, &scanned, &mut findings); } } diff --git a/api/crates/layerfs-control/tests/doctor.rs b/api/crates/layerfs-control/tests/doctor.rs index 29174b704b..ca89fd9367 100644 --- a/api/crates/layerfs-control/tests/doctor.rs +++ b/api/crates/layerfs-control/tests/doctor.rs @@ -348,3 +348,105 @@ fn a_layout_2_home_reports_what_refuses_its_conversion_and_converts_nothing() { assert!(stale.exists()); std::fs::remove_dir_all(home).unwrap(); } + +#[test] +fn a_stalled_daemon_endpoint_is_a_bounded_warning_and_starts_nothing() { + let home = new_home("stalled"); + home::open(&home).unwrap(); + store(&home, "shop", sqlite("shop", "native")); + let project = SdkValue::map([("name", t("api"))]); + write_entity(&paths::project_record(&home, "shop", "api"), &project).unwrap(); + let native = SdkValue::map([("name", t("native")), ("platform", t("native"))]); + write_entity(&paths::machine_record(&home, "native"), &native).unwrap(); + let sandbox = SdkValue::map([ + ("name", t("sb")), + ("project", t("shop/api")), + ("machine", t("native")), + ("id", t("sb")), + ]); + write_entity(&paths::sandbox_record(&home, "sb"), &sandbox).unwrap(); + // a daemon endpoint that accepts and then says nothing: the connect + // succeeds and only the bounded handshake read ends the query + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let endpoint = listener.local_addr().unwrap(); + let (dialed, dialed_rx) = mpsc::channel(); + std::thread::spawn(move || { + if let Ok((stream, _)) = listener.accept() { + let _ = dialed.send(()); + std::thread::sleep(Duration::from_secs(6)); + drop(stream); + } + }); + let keys = SdkValue::map([ + ("endpoint", t(&endpoint.to_string())), + ("secret", SdkValue::Bytes(vec![1; 32])), + ("peer", SdkValue::Bytes(vec![2; 32])), + ("instance", SdkValue::Bytes(vec![3; 32])), + ]); + write_record(&paths::sandbox_control(&home, "sb"), &keys).unwrap(); + + let before = tree(&home); + let at = std::time::Instant::now(); + let report = doctor(&home).unwrap(); + let elapsed = at.elapsed(); + assert!( + elapsed < Duration::from_secs(4), + "the doctor stalled for {elapsed:?}" + ); + assert!( + elapsed >= Duration::from_secs(1), + "the doctor did not wait for its bounded query: {elapsed:?}" + ); + dialed_rx + .recv_timeout(Duration::from_secs(2)) + .expect("the doctor never dialed the endpoint"); + assert_eq!(before, tree(&home), "the doctor wrote in the home"); + // a daemon that does not answer is a warning, not an error: the doctor + // stays read-only and does not fail on an idle or stopped daemon + assert_eq!(report.get("ok"), Some(&SdkValue::Bool(true)), "{report:?}"); + let found = findings(&report); + assert_eq!(found.len(), 1, "{found:#?}"); + let (severity, kind, name, message, fix) = &found[0]; + assert_eq!( + (severity.as_str(), kind.as_str(), name.as_str()), + ("warning", "sandbox", "sb") + ); + assert!(message.contains(&endpoint.to_string()), "{message}"); + assert!( + message.contains("backend.daemon.connection_failures"), + "{message}" + ); + assert!(message.contains("within 2s"), "{message}"); + assert!(fix.contains("sandbox get sb"), "{fix}"); + std::fs::remove_dir_all(home).unwrap(); +} + +#[test] +fn a_sandbox_without_a_recorded_endpoint_is_not_queried() { + let home = new_home("noendpoint"); + home::open(&home).unwrap(); + store(&home, "shop", sqlite("shop", "native")); + let project = SdkValue::map([("name", t("api"))]); + write_entity(&paths::project_record(&home, "shop", "api"), &project).unwrap(); + let sandbox = SdkValue::map([ + ("name", t("sb")), + ("project", t("shop/api")), + ("machine", t("native")), + ("id", t("sb")), + ]); + write_entity(&paths::sandbox_record(&home, "sb"), &sandbox).unwrap(); + // daemon keys without an endpoint: nothing tells the doctor where to + // dial, and it starts nothing to find out + let keys = SdkValue::map([ + ("secret", SdkValue::Bytes(vec![1; 32])), + ("peer", SdkValue::Bytes(vec![2; 32])), + ("instance", SdkValue::Bytes(vec![3; 32])), + ]); + write_record(&paths::sandbox_control(&home, "sb"), &keys).unwrap(); + let at = std::time::Instant::now(); + let report = doctor(&home).unwrap(); + assert!(at.elapsed() < Duration::from_secs(1)); + assert_eq!(report.get("ok"), Some(&SdkValue::Bool(true))); + assert!(findings(&report).is_empty(), "{report:?}"); + std::fs::remove_dir_all(home).unwrap(); +} From 31375c942e9be48c112ec2ffa334ae535e491aac Mon Sep 17 00:00:00 2001 From: rain Date: Wed, 4 Nov 2026 16:15:43 +0800 Subject: [PATCH 05/18] fix(control,daemon): move tests out of product source and type the capacity model (#543) - Remove every inline #[cfg(test)] module from product src/: the bridge admission encoding/classification tests move to engine/crates/layerfs-bridge/tests/admission.rs; the private pool, doctor, daemon connection/owner/retained unit tests are deleted because they cannot reach the code through a public API without new test-only surface. Their coverage is replaced by public-behavior tests (doctor capacity warnings via a fake authenticated daemon, bridge capacity DTO) and the existing real-TCP/in-process suites. - Remove the never-constructed NotAdmitted::Starting variant and its match arms; AdmissionReason::Starting (the daemon notice) stays. - Box Finished::Retained's record to satisfy clippy::large_enum_variant now that the Starting error no longer masks it. - Add a typed CapacityModel/AdmissionModel/RetainedModel DTO to layerfs-bridge as the one wire contract: the daemon producer builds it, sandbox.get and doctor parse it once, and OPERATION replaces the duplicated method-name literal. - Relocate the doctor capacity-warning tests to public doctor() calls against a fake authenticated daemon (healthy, retained+exhausted, and Capacity refusal). --- .../layerfs-control/src/daemon/operator.rs | 2 +- api/crates/layerfs-control/src/daemon/pool.rs | 195 +------ .../layerfs-control/src/doctor/capacity.rs | 182 ++----- .../layerfs-control/src/sandbox/direct.rs | 2 +- .../layerfs-control/src/sandbox/dispatch.rs | 4 +- api/crates/layerfs-control/src/sandbox/get.rs | 9 +- api/crates/layerfs-control/tests/doctor.rs | 202 +++++++- engine/crates/layerfs-bridge/src/control.rs | 4 + .../layerfs-bridge/src/control_capacity.rs | 214 ++++++++ .../layerfs-bridge/src/duplex/admission.rs | 29 -- engine/crates/layerfs-bridge/src/lib.rs | 1 + .../crates/layerfs-bridge/tests/admission.rs | 29 ++ .../layerfs-bridge/tests/capacity_model.rs | 74 +++ .../src/application/connection.rs | 484 ++---------------- .../layerfs-daemon/src/application/owner.rs | 125 +---- .../src/application/retained.rs | 125 ----- 16 files changed, 605 insertions(+), 1076 deletions(-) create mode 100644 engine/crates/layerfs-bridge/src/control_capacity.rs create mode 100644 engine/crates/layerfs-bridge/tests/admission.rs create mode 100644 engine/crates/layerfs-bridge/tests/capacity_model.rs diff --git a/api/crates/layerfs-control/src/daemon/operator.rs b/api/crates/layerfs-control/src/daemon/operator.rs index 2d84d2a5b0..325c506b1c 100644 --- a/api/crates/layerfs-control/src/daemon/operator.rs +++ b/api/crates/layerfs-control/src/daemon/operator.rs @@ -11,7 +11,7 @@ pub fn call(control: &mut Control, method: &str, args: SdkValue) -> SdkResult { match method { // The daemon's control admission and bounded retained-failure store // (#540): an operator read model, never a product operation. - "backend.daemon.connection_failures" => { + layerfs_bridge::control::CAPACITY_OPERATION => { crate::daemon::call::exchange_call(control, method, args) } "sandbox.list_workspaces" => crate::daemon::call::exchange_call(control, method, args), diff --git a/api/crates/layerfs-control/src/daemon/pool.rs b/api/crates/layerfs-control/src/daemon/pool.rs index c9064df7a9..a7cb65eb79 100644 --- a/api/crates/layerfs-control/src/daemon/pool.rs +++ b/api/crates/layerfs-control/src/daemon/pool.rs @@ -71,8 +71,6 @@ enum NotAdmitted { /// The daemon had no vacant pool slot. `retained` is exact when the /// advisory capacity notice arrived, and unknown when only EOF was seen. NoVacantSlot { retained: Option }, - /// The daemon is still starting and admits no control yet. - Starting, /// The connection itself failed before Hello (`BrokenPipe`, /// `ConnectionReset`). ConnectionFailed, @@ -82,14 +80,13 @@ impl NotAdmitted { fn code(self) -> &'static str { match self { Self::NoVacantSlot { .. } => "Capacity", - Self::Starting | Self::ConnectionFailed => "Unavailable", + Self::ConnectionFailed => "Unavailable", } } fn admission(self) -> &'static str { match self { Self::NoVacantSlot { .. } => "no-vacant-slot", - Self::Starting => "starting", Self::ConnectionFailed => "connection-failed", } } @@ -166,10 +163,6 @@ fn admission_refusal(wait: Duration, admission: NotAdmitted, kind: &str) -> SdkR " (it reported {count} retained failure record(s))" )) ), - NotAdmitted::Starting => format!( - "the Sandbox's daemon is still starting and admitted no control connection for {}s ({kind}). The call was not admitted; retrying is safe", - wait.as_secs() - ), NotAdmitted::ConnectionFailed => format!( "the connection to the Sandbox's daemon failed before Hello for {}s ({kind}): the call was not admitted; retrying is safe", wait.as_secs() @@ -450,189 +443,3 @@ impl DerefMut for Lease<'_> { self.control.as_mut().expect("lent connection") } } - -#[cfg(test)] -mod tests { - use super::*; - use layerfs_bridge::duplex::admission::encode; - use std::io::Write; - use std::net::TcpListener; - use std::thread; - - fn failed_open(message: &str) -> SdkRefusal { - refused("Failed", message) - } - - #[test] - fn eof_fallback_is_capacity_with_unknown_retained() { - let (admission, kind) = not_admitted(&failed_open("Io(Kind(UnexpectedEof))")).unwrap(); - assert_eq!(kind, "UnexpectedEof"); - assert!(matches!( - admission, - NotAdmitted::NoVacantSlot { retained: None } - )); - let capacity = admission_refusal(Duration::from_secs(60), admission, kind); - assert_eq!(capacity.code, "Capacity"); - assert!(capacity.message.contains("no vacant control slot")); - assert!(capacity.message.contains("UnexpectedEof")); - assert!(!capacity.message.contains("other processes")); - assert_eq!( - capacity.detail.get_text("resource"), - Some("daemon_control_slot") - ); - assert!(matches!( - capacity.detail.get("retained"), - Some(SdkValue::Null) - )); - assert_eq!(capacity.detail.get_bool("retryable"), true); - assert_eq!( - capacity.detail.get_text("admission"), - Some("no-vacant-slot") - ); - } - - #[test] - fn reset_is_unavailable() { - for kind in ["BrokenPipe", "ConnectionReset"] { - let (admission, observed) = - not_admitted(&failed_open(&format!("Io(Kind({kind}))"))).unwrap(); - assert_eq!(observed, kind); - assert_eq!(admission, NotAdmitted::ConnectionFailed); - let failure = admission_refusal(Duration::from_secs(60), admission, kind); - assert_eq!(failure.code, "Unavailable"); - assert!(failure.message.contains(kind)); - assert!(!failure.message.contains("other processes")); - assert!(matches!( - failure.detail.get("resource"), - Some(SdkValue::Null) - )); - assert_eq!(failure.detail.get_bool("retryable"), true); - assert_eq!( - failure.detail.get_text("admission"), - Some("connection-failed") - ); - } - } - - #[test] - fn other_refusals_are_not_admission_refusals() { - assert_eq!(not_admitted(&refused("StaleSandbox", "saved daemon")), None); - assert_eq!(not_admitted(&failed_open("Io(Kind(TimedOut))")), None); - } - - #[test] - fn notice_maps_to_capacity_with_exact_retained() { - let notice = AdmissionNotice::new(AdmissionReason::NoPoolSlot, 8, 0, 1); - let refusal = notice_refusal(notice); - assert_eq!(refusal.code, "Capacity"); - assert_eq!(refusal.detail.get_int("retained"), Some(8)); - assert_eq!(refusal.detail.get_int("pool_vacant"), Some(0)); - assert_eq!(refusal.detail.get_int("reserved_vacant"), Some(1)); - assert_eq!(refusal.detail.get_bool("retryable"), true); - assert_eq!( - refusal.detail.get_text("resource"), - Some("daemon_control_slot") - ); - assert!(!refusal.message.contains("other processes")); - } - - #[test] - fn starting_notice_is_unavailable() { - let refusal = notice_refusal(AdmissionNotice::new(AdmissionReason::Starting, 0, 0, 1)); - assert_eq!(refusal.code, "Unavailable"); - assert_eq!(refusal.detail.get_text("admission"), Some("starting")); - assert_eq!(refusal.detail.get_bool("retryable"), true); - } - - #[test] - fn garbage_before_hello_is_not_a_notice() { - // A 24-byte record that is not the magic is a handshake failure, not - // a false Capacity. - let listener = TcpListener::bind("127.0.0.1:0").unwrap(); - let address = listener.local_addr().unwrap(); - thread::spawn(move || { - for mut stream in listener.incoming().flatten() { - let _ = stream.write_all(&[0u8; 26]); - } - }); - let dial = Dial { - endpoint: address, - host: None, - secret: [7; 32], - peer: layerfs_bridge::duplex::public_key(&[8; 32]).unwrap(), - instance: [9; 32], - }; - let refusal = match dial.open_admitted(Duration::from_millis(80)) { - Ok(_) => panic!("a refusing daemon admitted the dial"), - Err(refusal) => refusal, - }; - assert_ne!(refusal.code, "Capacity", "{refusal:?}"); - assert!(!refusal.message.contains("other processes")); - } - - #[test] - fn a_daemon_that_closes_before_hello_refuses_precisely() { - let listener = TcpListener::bind("127.0.0.1:0").unwrap(); - let address = listener.local_addr().unwrap(); - // The daemon's accept loop with no vacant slot: accept once, close. - thread::spawn(move || { - for stream in listener.incoming() { - drop(stream); - } - }); - let dial = Dial { - endpoint: address, - host: None, - secret: [7; 32], - peer: layerfs_bridge::duplex::public_key(&[8; 32]).unwrap(), - instance: [9; 32], - }; - let Err(refusal) = dial.open_admitted(Duration::from_millis(120)) else { - panic!("a daemon that closes before Hello was admitted"); - }; - assert_eq!(refusal.code, "Capacity", "{refusal:?}"); - assert!( - !refusal.message.contains("other processes"), - "{}", - refusal.message - ); - assert!( - refusal.message.contains("not admitted"), - "{}", - refusal.message - ); - } - - #[test] - fn a_capacity_notice_is_classified_before_hello() { - let listener = TcpListener::bind("127.0.0.1:0").unwrap(); - let address = listener.local_addr().unwrap(); - thread::spawn(move || { - for mut stream in listener.incoming().flatten() { - let body = encode(&AdmissionNotice::new(AdmissionReason::NoPoolSlot, 8, 0, 1)); - let mut framed = vec![0u8; 2 + body.len()]; - framed[..2].copy_from_slice(&(body.len() as u16).to_be_bytes()); - framed[2..].copy_from_slice(&body); - let _ = stream.write_all(&framed); - let _ = stream.shutdown(std::net::Shutdown::Write); - // Drain so the client's shutdown is not a reset. - let mut sink = [0u8; 64]; - let _ = std::io::Read::read(&mut stream, &mut sink); - } - }); - let dial = Dial { - endpoint: address, - host: None, - secret: [7; 32], - peer: layerfs_bridge::duplex::public_key(&[8; 32]).unwrap(), - instance: [9; 32], - }; - let refusal = match dial.open_admitted(Duration::from_millis(80)) { - Ok(_) => panic!("a refusing daemon admitted the dial"), - Err(refusal) => refusal, - }; - assert_eq!(refusal.code, "Capacity", "{refusal:?}"); - assert_eq!(refusal.detail.get_int("retained"), Some(8)); - assert_eq!(refusal.detail.get_bool("retryable"), true); - } -} diff --git a/api/crates/layerfs-control/src/doctor/capacity.rs b/api/crates/layerfs-control/src/doctor/capacity.rs index 33f5916992..648e84efff 100644 --- a/api/crates/layerfs-control/src/doctor/capacity.rs +++ b/api/crates/layerfs-control/src/doctor/capacity.rs @@ -14,7 +14,7 @@ use crate::common::secrets; use crate::daemon::operator; use crate::sandbox::direct; use crate::sandbox::record::SandboxRecord; -use layerfs_bridge::control::{SdkRefusal, SdkValue}; +use layerfs_bridge::control::{CapacityModel, SdkRefusal, SdkValue}; use std::net::SocketAddr; use std::path::Path; use std::sync::mpsc; @@ -22,7 +22,7 @@ use std::time::Duration; /// The daemon's operator read model of control admission and retained /// connection failures. -const OPERATION: &str = "backend.daemon.connection_failures"; +const OPERATION: &str = layerfs_bridge::control::CAPACITY_OPERATION; /// How long one daemon query may take: connecting, its Hello and its one /// exchange. Short on purpose: the doctor must not stall behind a daemon @@ -44,7 +44,7 @@ pub(super) fn check(home: &Path, scanned: &Scanned, findings: &mut Findings) { continue; }; match probe_bounded(home, sandbox, endpoint) { - Ok(value) => capacity(findings, name, endpoint, &value), + Ok(value) => capacity(findings, name, endpoint, &CapacityModel::parse(&value)), Err(refusal) => unanswered(findings, name, endpoint, &refusal), } } @@ -148,152 +148,42 @@ fn unanswered(findings: &mut Findings, name: &str, endpoint: SocketAddr, refusal /// The warnings the daemon's capacity model gives: retained connection /// failures, and a pool with no vacant control slot. -fn capacity(findings: &mut Findings, name: &str, endpoint: SocketAddr, value: &SdkValue) { - let number = |value: &SdkValue, field: &str| value.get_int(field).unwrap_or(0); - if let Some(retained) = value.get("retained") { - let count = number(retained, "count"); - if count > 0 { - findings.warning( - ("sandbox", name), - format!( - "Sandbox {name}'s daemon at {endpoint} retained {count} of {} connection failure record(s) ({} dropped): calls it refused before Hello are kept there for {:.1}s", - number(retained, "limit"), - number(retained, "dropped"), - number(retained, "ttl_ms") as f64 / 1000.0 - ), - format!( - "`layerfs sandbox get {name}` shows the daemon's daemon_capacity, the `{OPERATION}` read model" - ), - ); - } - } - if let Some(admission) = value.get("admission") { - let vacant = number(admission, "pool_vacant"); - let running = number(admission, "pool_running"); - if vacant == 0 && running > 0 { - findings.warning( - ("sandbox", name), - format!( - "Sandbox {name}'s daemon at {endpoint} has no vacant pool control slot (pool_vacant {vacant}, pool_running {running}, reserved_vacant {}, reserved_running {}); a call that needs one is refused Capacity on resource daemon_control_slot", - number(admission, "reserved_vacant"), - number(admission, "reserved_running") - ), - format!( - "end the calls that hold its control slots, or wait for them to end; `layerfs sandbox get {name}` shows the daemon's daemon_capacity, the `{OPERATION}` read model" - ), - ); - } +fn capacity(findings: &mut Findings, name: &str, endpoint: SocketAddr, model: &CapacityModel) { + let retained = &model.retained; + if retained.count > 0 { + findings.warning( + ("sandbox", name), + format!( + "Sandbox {name}'s daemon at {endpoint} retained {} of {} connection failure record(s) ({} dropped): calls it refused before Hello are kept there for {:.1}s", + retained.count, + retained.limit, + retained.dropped, + retained.ttl_ms as f64 / 1000.0 + ), + capacity_fix(name), + ); } -} - -#[cfg(test)] -mod tests { - use super::*; - - fn model( - pool_vacant: i64, - pool_running: i64, - count: i64, - limit: i64, - dropped: i64, - ) -> SdkValue { - SdkValue::map([ - ( - "admission", - SdkValue::map([ - ("pool_vacant", SdkValue::Int(pool_vacant)), - ("pool_running", SdkValue::Int(pool_running)), - ("reserved_vacant", SdkValue::Int(1)), - ("reserved_running", SdkValue::Int(0)), - ]), + let admission = &model.admission; + if admission.exhausted() { + findings.warning( + ("sandbox", name), + format!( + "Sandbox {name}'s daemon at {endpoint} has no vacant pool control slot (pool_vacant {}, pool_running {}, reserved_vacant {}, reserved_running {}); a call that needs one is refused Capacity on resource daemon_control_slot", + admission.pool_vacant, + admission.pool_running, + admission.reserved_vacant, + admission.reserved_running ), - ( - "retained", - SdkValue::map([ - ("limit", SdkValue::Int(limit)), - ("ttl_ms", SdkValue::Int(3_600_000)), - ("count", SdkValue::Int(count)), - ("dropped", SdkValue::Int(dropped)), - ("recorded", SdkValue::Int(count)), - ("failures", SdkValue::List(Vec::new())), - ]), + format!( + "end the calls that hold its control slots, or wait for them to end; `layerfs sandbox get {name}` shows the daemon's daemon_capacity, the `{OPERATION}` read model" ), - ]) - } - - fn findings(value: &SdkValue) -> SdkValue { - let mut found = Findings::default(); - let endpoint: SocketAddr = "127.0.0.1:1".parse().unwrap(); - capacity(&mut found, "sb", endpoint, value); - found.to_sdk() - } - - #[test] - fn retained_failures_and_an_exhausted_pool_are_warnings_with_their_counts() { - let report = findings(&model(0, 8, 3, 64, 2)); - assert_eq!(report.get("ok"), Some(&SdkValue::Bool(true))); - let SdkValue::List(items) = report.get("findings").unwrap() else { - panic!("no findings"); - }; - assert_eq!(items.len(), 2, "{report:?}"); - let text: Vec = items - .iter() - .map(|item| { - format!( - "{} {}", - item.get_text("message").unwrap(), - item.get_text("fix").unwrap() - ) - }) - .collect(); - assert!(text[0].contains("retained 3 of 64"), "{text:?}"); - assert!(text[0].contains("2 dropped"), "{text:?}"); - assert!(text[0].contains(OPERATION), "{text:?}"); - assert!(text[1].contains("pool_vacant 0"), "{text:?}"); - assert!(text[1].contains("pool_running 8"), "{text:?}"); - assert!(text[1].contains("Capacity"), "{text:?}"); - assert!(text[1].contains("daemon_control_slot"), "{text:?}"); - assert!(text[1].contains(OPERATION), "{text:?}"); - for item in items { - assert_eq!(item.get_text("severity"), Some("warning")); - } - } - - #[test] - fn a_healthy_daemon_gives_no_finding() { - let report = findings(&model(7, 1, 0, 64, 0)); - assert_eq!(report.get("ok"), Some(&SdkValue::Bool(true))); - assert!(matches!(report.get("findings"), Some(SdkValue::List(items)) if items.is_empty())); + ); } +} - #[test] - fn an_exhausted_pool_refusal_is_a_capacity_warning_not_an_error() { - let refusal = SdkRefusal { - code: "Capacity".to_owned(), - message: "the Sandbox's daemon has no vacant control slot".to_owned(), - detail: SdkValue::map([ - ("resource", SdkValue::text("daemon_control_slot")), - ("retained", SdkValue::Int(3)), - ("pool_vacant", SdkValue::Int(0)), - ("reserved_vacant", SdkValue::Int(1)), - ("retryable", SdkValue::Bool(true)), - ]), - }; - let mut found = Findings::default(); - let endpoint: SocketAddr = "127.0.0.1:1".parse().unwrap(); - unanswered(&mut found, "sb", endpoint, &refusal); - let report = found.to_sdk(); - assert_eq!(report.get("ok"), Some(&SdkValue::Bool(true))); - let SdkValue::List(items) = report.get("findings").unwrap() else { - panic!("no findings"); - }; - assert_eq!(items.len(), 1, "{report:?}"); - let message = items[0].get_text("message").unwrap(); - assert!(message.contains("Capacity"), "{message}"); - assert!(message.contains("daemon_control_slot"), "{message}"); - assert!(message.contains("pool_vacant 0"), "{message}"); - assert!(message.contains("reserved_vacant 1"), "{message}"); - assert!(message.contains("retained 3"), "{message}"); - assert_eq!(items[0].get_text("severity"), Some("warning")); - } +/// Where the operator finds the model a capacity warning came from. +fn capacity_fix(name: &str) -> String { + format!( + "`layerfs sandbox get {name}` shows the daemon's daemon_capacity, the `{OPERATION}` read model" + ) } diff --git a/api/crates/layerfs-control/src/sandbox/direct.rs b/api/crates/layerfs-control/src/sandbox/direct.rs index ad3c2e9703..60d340e33c 100644 --- a/api/crates/layerfs-control/src/sandbox/direct.rs +++ b/api/crates/layerfs-control/src/sandbox/direct.rs @@ -344,7 +344,7 @@ pub(crate) fn call( (found == id).then_some(head) }) } - "sandbox.list_workspaces" | "backend.daemon.connection_failures" => { + "sandbox.list_workspaces" | layerfs_bridge::control::CAPACITY_OPERATION => { dispatch::call(op, args) } _ => Err(refused( diff --git a/api/crates/layerfs-control/src/sandbox/dispatch.rs b/api/crates/layerfs-control/src/sandbox/dispatch.rs index e838760f5e..02bdbf72b2 100644 --- a/api/crates/layerfs-control/src/sandbox/dispatch.rs +++ b/api/crates/layerfs-control/src/sandbox/dispatch.rs @@ -27,7 +27,7 @@ pub fn call(op: &str, args: SdkValue) -> Outcome { } // The operator view of control admission and retained failures // (#540). It is a read model, never a product operation. - "backend.daemon.connection_failures" => daemon_backend(op, args), + layerfs_bridge::control::CAPACITY_OPERATION => daemon_backend(op, args), "sandbox.create" => crate::sandbox::serve::create(&args), "sandbox.close" => crate::sandbox::serve::close(&args), "workspace.mount" => workspace::mount(&args), @@ -124,7 +124,7 @@ fn daemon_backend(op: &str, args: SdkValue) -> Outcome { } /// The daemon's control-capacity/retained-failure read model (#540). -const CAPACITY_QUERY: &str = "backend.daemon.connection_failures"; +const CAPACITY_QUERY: &str = layerfs_bridge::control::CAPACITY_OPERATION; /// How long a best-effort capacity read waits for control admission. const CAPACITY_WAIT: std::time::Duration = std::time::Duration::from_secs(2); diff --git a/api/crates/layerfs-control/src/sandbox/get.rs b/api/crates/layerfs-control/src/sandbox/get.rs index a2d229d795..3a999e07a4 100644 --- a/api/crates/layerfs-control/src/sandbox/get.rs +++ b/api/crates/layerfs-control/src/sandbox/get.rs @@ -69,20 +69,23 @@ fn daemon_capacity( direct::call( context, record, - "backend.daemon.connection_failures", + layerfs_bridge::control::CAPACITY_OPERATION, vec![], ) } else { reach( context, record, - "backend.daemon.connection_failures", + layerfs_bridge::control::CAPACITY_OPERATION, vec![], false, ) .ok()? }; - outcome.ok() + // Parse the one typed contract, then publish exactly that shape: a daemon + // that answers something else is not passed through as capacity. + let answer = outcome.ok()?; + Some(layerfs_bridge::control::CapacityModel::parse(&answer).to_sdk()) } /// Workspace `item` of Sandbox `sandbox` with its `ws` (#536 C3): diff --git a/api/crates/layerfs-control/tests/doctor.rs b/api/crates/layerfs-control/tests/doctor.rs index ca89fd9367..34565faf0e 100644 --- a/api/crates/layerfs-control/tests/doctor.rs +++ b/api/crates/layerfs-control/tests/doctor.rs @@ -1,13 +1,19 @@ //! `layerfs doctor` (#536 H7): a home with one of each problem gives one //! finding each, naming the call that fixes it; a clean home is `ok` with //! no findings; a layout 2 home reports what refuses its conversion; and -//! the doctor writes nothing in the home. -use layerfs_bridge::control::SdkValue; +//! the doctor writes nothing in the home. A live fake daemon's capacity model +//! is explained as warnings, and its Capacity refusal is a warning, not an +//! error. +use layerfs_bridge::control::{ + AdmissionModel, Answer, Call, CapacityModel, DaemonPhase, DaemonStatus, Reply, Request, + RetainedModel, SdkRefusal, SdkValue, CAPACITY_OPERATION, +}; +use layerfs_bridge::duplex; use layerfs_control::common::home::{self, paths, private_dir, write_entity, write_record}; use layerfs_control::doctor::doctor; use layerfs_control::machine::worker::{read_frame, read_frame_within, write_frame, MAX_HELLO}; use std::collections::BTreeMap; -use std::net::TcpListener; +use std::net::{SocketAddr, TcpListener}; use std::os::unix::fs::{MetadataExt, PermissionsExt}; use std::path::{Path, PathBuf}; use std::sync::mpsc; @@ -450,3 +456,193 @@ fn a_sandbox_without_a_recorded_endpoint_is_not_queried() { assert!(findings(&report).is_empty(), "{report:?}"); std::fs::remove_dir_all(home).unwrap(); } + +/// A fake daemon that answers the doctor's two calls: its Hello, then the +/// control-capacity read model with `reply`. +fn capacity_daemon(reply: Reply) -> (SocketAddr, std::thread::JoinHandle<()>) { + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let endpoint = listener.local_addr().unwrap(); + let worker = std::thread::spawn(move || { + let (stream, _) = listener.accept().unwrap(); + stream + .set_read_timeout(Some(Duration::from_secs(5))) + .unwrap(); + stream + .set_write_timeout(Some(Duration::from_secs(5))) + .unwrap(); + let mut channel = duplex::accept( + stream, + &DAEMON_PRIVATE, + duplex::public_key(&CLIENT_PRIVATE).unwrap(), + ) + .unwrap(); + let hello = Call::decode(channel.receive.receive().unwrap()).unwrap(); + assert!(matches!(hello.request, Request::Hello(_))); + channel + .send + .send( + &Answer { + id: hello.id, + reply: Reply::Hello(DaemonStatus { + instance: DAEMON_INSTANCE, + phase: DaemonPhase::ControlReady, + overlay_sqlite: Some("3.51.0".into()), + store_sqlite: Some("3.51.0".into()), + }), + } + .encode() + .unwrap(), + ) + .unwrap(); + let call = Call::decode(channel.receive.receive().unwrap()).unwrap(); + let id = call.id; + let Request::Sdk(sdk) = call.request else { + panic!("expected the capacity read model"); + }; + assert_eq!(sdk.method, CAPACITY_OPERATION); + channel + .send + .send(&Answer { id, reply }.encode().unwrap()) + .unwrap(); + }); + (endpoint, worker) +} + +const CLIENT_PRIVATE: [u8; 32] = [2; 32]; +const DAEMON_PRIVATE: [u8; 32] = [1; 32]; +const DAEMON_INSTANCE: [u8; 32] = [3; 32]; + +/// A homes home with one running Sandbox whose daemon keys name `endpoint`. +fn running_sandbox(home: &Path, endpoint: SocketAddr) { + home::open(home).unwrap(); + store(home, "shop", sqlite("shop", "native")); + let project = SdkValue::map([("name", t("api"))]); + write_entity(&paths::project_record(home, "shop", "api"), &project).unwrap(); + let native = SdkValue::map([("name", t("native")), ("platform", t("native"))]); + write_entity(&paths::machine_record(home, "native"), &native).unwrap(); + let sandbox = SdkValue::map([ + ("name", t("sb")), + ("project", t("shop/api")), + ("machine", t("native")), + ("id", t("sb")), + ]); + write_entity(&paths::sandbox_record(home, "sb"), &sandbox).unwrap(); + let keys = SdkValue::map([ + ("endpoint", t(&endpoint.to_string())), + ("secret", SdkValue::Bytes(CLIENT_PRIVATE.to_vec())), + ( + "peer", + SdkValue::Bytes(duplex::public_key(&DAEMON_PRIVATE).unwrap().to_vec()), + ), + ("instance", SdkValue::Bytes(DAEMON_INSTANCE.to_vec())), + ]); + write_record(&paths::sandbox_control(home, "sb"), &keys).unwrap(); +} + +#[test] +fn capacity_model_warnings_name_retained_failures_and_an_exhausted_pool() { + let model = layerfs_bridge::control::CapacityModel { + admission: AdmissionModel { + pool_vacant: 0, + pool_running: 8, + reserved_vacant: 1, + reserved_running: 0, + }, + retained: RetainedModel { + limit: 64, + ttl_ms: 3_600_000, + count: 3, + dropped: 2, + recorded: 3, + failures: Vec::new(), + }, + }; + let (endpoint, worker) = capacity_daemon(Reply::Sdk(model.to_sdk())); + let home = new_home("capacity"); + running_sandbox(&home, endpoint); + let report = doctor(&home).unwrap(); + worker.join().unwrap(); + assert_eq!(report.get("ok"), Some(&SdkValue::Bool(true)), "{report:?}"); + let found = findings(&report); + assert_eq!(found.len(), 2, "{found:#?}"); + let text: Vec = found + .iter() + .map(|(_, _, _, message, fix)| format!("{message} {fix}")) + .collect(); + assert!(text[0].contains("retained 3 of 64"), "{text:#?}"); + assert!(text[0].contains("2 dropped"), "{text:#?}"); + assert!( + text[0].contains("backend.daemon.connection_failures"), + "{text:#?}" + ); + assert!(text[1].contains("pool_vacant 0"), "{text:#?}"); + assert!(text[1].contains("pool_running 8"), "{text:#?}"); + assert!(text[1].contains("Capacity"), "{text:#?}"); + assert!(text[1].contains("daemon_control_slot"), "{text:#?}"); + for (severity, kind, name, _, _) in &found { + assert_eq!( + (severity.as_str(), kind.as_str(), name.as_str()), + ("warning", "sandbox", "sb") + ); + } + std::fs::remove_dir_all(home).unwrap(); +} + +#[test] +fn a_healthy_capacity_model_gives_no_finding() { + let model = CapacityModel { + admission: AdmissionModel { + pool_vacant: 7, + pool_running: 1, + reserved_vacant: 1, + reserved_running: 0, + }, + retained: RetainedModel { + limit: 64, + ttl_ms: 3_600_000, + count: 0, + dropped: 0, + recorded: 0, + failures: Vec::new(), + }, + }; + let (endpoint, worker) = capacity_daemon(Reply::Sdk(model.to_sdk())); + let home = new_home("capacity-healthy"); + running_sandbox(&home, endpoint); + let report = doctor(&home).unwrap(); + worker.join().unwrap(); + assert_eq!(report.get("ok"), Some(&SdkValue::Bool(true))); + assert!(findings(&report).is_empty(), "{report:?}"); + std::fs::remove_dir_all(home).unwrap(); +} + +#[test] +fn a_capacity_refusal_is_a_warning_not_an_error() { + let refusal = SdkRefusal { + code: "Capacity".to_owned(), + message: "the Sandbox's daemon has no vacant control slot".to_owned(), + detail: SdkValue::map([ + ("resource", t("daemon_control_slot")), + ("retained", SdkValue::Int(3)), + ("pool_vacant", SdkValue::Int(0)), + ("reserved_vacant", SdkValue::Int(1)), + ("retryable", SdkValue::Bool(true)), + ]), + }; + let (endpoint, worker) = capacity_daemon(Reply::SdkRefused(refusal)); + let home = new_home("capacity-refused"); + running_sandbox(&home, endpoint); + let report = doctor(&home).unwrap(); + worker.join().unwrap(); + assert_eq!(report.get("ok"), Some(&SdkValue::Bool(true))); + let found = findings(&report); + assert_eq!(found.len(), 1, "{found:#?}"); + let message = &found[0].3; + assert!(message.contains("Capacity"), "{message}"); + assert!(message.contains("daemon_control_slot"), "{message}"); + assert!(message.contains("pool_vacant 0"), "{message}"); + assert!(message.contains("reserved_vacant 1"), "{message}"); + assert!(message.contains("retained 3"), "{message}"); + assert_eq!(found[0].0, "warning"); + std::fs::remove_dir_all(home).unwrap(); +} diff --git a/engine/crates/layerfs-bridge/src/control.rs b/engine/crates/layerfs-bridge/src/control.rs index 727da40470..cb8dd79c5c 100644 --- a/engine/crates/layerfs-bridge/src/control.rs +++ b/engine/crates/layerfs-bridge/src/control.rs @@ -164,6 +164,10 @@ fn boolean(value: u8) -> Result { } } +pub use crate::control_capacity::{ + AdmissionModel, CapacityModel, RetainedFailureModel, RetainedModel, + OPERATION as CAPACITY_OPERATION, +}; pub use crate::control_forced::{ AbortDisposition, CommitKnowledge, DetachDisposition, ForceUnmounted, ForcedCleanup, ForcedFacts, ForcedOutcome, diff --git a/engine/crates/layerfs-bridge/src/control_capacity.rs b/engine/crates/layerfs-bridge/src/control_capacity.rs new file mode 100644 index 0000000000..61fe9819f3 --- /dev/null +++ b/engine/crates/layerfs-bridge/src/control_capacity.rs @@ -0,0 +1,214 @@ +//! The daemon's control-capacity read model (#540). +//! +//! One typed shape is the contract between the daemon that publishes it, the +//! operator read that forwards it, and the doctor that explains it: a +//! [`CapacityModel`] with one [`AdmissionModel`] (vacant and in-use control +//! slots by class) and one [`RetainedModel`] (the bounded store of connection +//! failures that used to retain a slot). It is a plain value object: parse a +//! daemon answer once, then read typed fields instead of string keys. +use crate::control::SdkValue; + +/// The daemon backend method that returns this read model. +pub const OPERATION: &str = "backend.daemon.connection_failures"; + +/// Vacant and in-use control slots by admission class. +#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)] +pub struct AdmissionModel { + /// Pool slots that no connection holds. + pub pool_vacant: i64, + /// Pool slots that an admitted connection holds. + pub pool_running: i64, + /// Reserved installer slots that no connection holds. + pub reserved_vacant: i64, + /// Reserved installer slots that an admitted connection holds. + pub reserved_running: i64, +} + +impl AdmissionModel { + /// The model in `value`, or all zero when the record does not carry one. + pub fn parse(value: &SdkValue) -> Self { + let admission = value.get("admission").unwrap_or(&SdkValue::Null); + Self { + pool_vacant: admission.get_int("pool_vacant").unwrap_or(0), + pool_running: admission.get_int("pool_running").unwrap_or(0), + reserved_vacant: admission.get_int("reserved_vacant").unwrap_or(0), + reserved_running: admission.get_int("reserved_running").unwrap_or(0), + } + } + + /// The model as the read model's `admission` record. + pub fn to_sdk(&self) -> SdkValue { + SdkValue::map([ + ("pool_vacant", SdkValue::Int(self.pool_vacant)), + ("pool_running", SdkValue::Int(self.pool_running)), + ("reserved_vacant", SdkValue::Int(self.reserved_vacant)), + ("reserved_running", SdkValue::Int(self.reserved_running)), + ]) + } + + /// Whether the pool has no vacant slot while it is in use at all. + pub fn exhausted(&self) -> bool { + self.pool_vacant == 0 && self.pool_running > 0 + } +} + +/// One connection failure that used to retain a control slot. +#[derive(Clone, Debug, Eq, PartialEq)] +pub struct RetainedFailureModel { + /// Slot the failed worker occupied; it is already free for a new connection. + pub slot: i64, + /// `pool` or `reserved`: the class of the slot that was released. + pub class: String, + /// Admission generation of the released worker. + pub generation: i64, + /// The worker that failed: daemon instance, pid and thread. + pub owner: String, + /// Bytes of a request that failed decoding, when one was received. + pub received_bytes: Option, + /// `control` or `install` when a request was decoded. + pub request: Option, + /// Whether the original reply was sent before the failure. + pub reply_sent: bool, + /// Bounded textual deciding cause. + pub cause: String, + /// Original socket fence failure, when one was observed. + pub fence_error: Option, + /// Distinct failed diagnostic transfer, when one happened. + pub diagnostic_error: Option, + /// Age at the observation that returned this record, in milliseconds. + pub age_ms: i64, + /// Remaining lifetime at the observation that returned this record, in + /// milliseconds. + pub expires_in_ms: i64, +} + +impl RetainedFailureModel { + /// The record in `value`, or `None` when it is not a failure record. + pub fn parse(value: &SdkValue) -> Option { + Some(Self { + slot: value.get_int("slot")?, + class: value.get_text("class")?.to_owned(), + generation: value.get_int("generation")?, + owner: value.get_text("owner")?.to_owned(), + received_bytes: value.get_int("received_bytes"), + request: value.get_text("request").map(str::to_owned), + reply_sent: value.get_bool("reply_sent"), + cause: value.get_text("cause")?.to_owned(), + fence_error: value.get_text("fence_error").map(str::to_owned), + diagnostic_error: value.get_text("diagnostic_error").map(str::to_owned), + age_ms: value.get_int("age_ms")?, + expires_in_ms: value.get_int("expires_in_ms")?, + }) + } + + /// The record as the read model's `retained.failures` item. + pub fn to_sdk(&self) -> SdkValue { + SdkValue::map([ + ("slot", SdkValue::Int(self.slot)), + ("class", SdkValue::text(&self.class)), + ("generation", SdkValue::Int(self.generation)), + ("owner", SdkValue::text(&self.owner)), + ( + "received_bytes", + self.received_bytes.map_or(SdkValue::Null, SdkValue::Int), + ), + ("request", SdkValue::opt_text(self.request.clone())), + ("reply_sent", SdkValue::Bool(self.reply_sent)), + ("cause", SdkValue::text(&self.cause)), + ("fence_error", SdkValue::opt_text(self.fence_error.clone())), + ( + "diagnostic_error", + SdkValue::opt_text(self.diagnostic_error.clone()), + ), + ("age_ms", SdkValue::Int(self.age_ms)), + ("expires_in_ms", SdkValue::Int(self.expires_in_ms)), + ]) + } +} + +/// The bounded store of connection failures that used to retain a slot. +#[derive(Clone, Debug, Default, Eq, PartialEq)] +pub struct RetainedModel { + /// Most records the store keeps at once. + pub limit: i64, + /// How long a record stays operator-visible, in milliseconds. + pub ttl_ms: i64, + /// Visible records. + pub count: i64, + /// Records evicted by the limit or the TTL since startup. + pub dropped: i64, + /// Total records ever recorded since startup. + pub recorded: i64, + /// Visible records, oldest first. + pub failures: Vec, +} + +impl RetainedModel { + /// The model in `value`, or all zero when the record does not carry one. + pub fn parse(value: &SdkValue) -> Self { + let retained = value.get("retained").unwrap_or(&SdkValue::Null); + let failures = match retained.get("failures") { + Some(SdkValue::List(items)) => items + .iter() + .filter_map(RetainedFailureModel::parse) + .collect(), + _ => Vec::new(), + }; + Self { + limit: retained.get_int("limit").unwrap_or(0), + ttl_ms: retained.get_int("ttl_ms").unwrap_or(0), + count: retained.get_int("count").unwrap_or(0), + dropped: retained.get_int("dropped").unwrap_or(0), + recorded: retained.get_int("recorded").unwrap_or(0), + failures, + } + } + + /// The model as the read model's `retained` record. + pub fn to_sdk(&self) -> SdkValue { + SdkValue::map([ + ("limit", SdkValue::Int(self.limit)), + ("ttl_ms", SdkValue::Int(self.ttl_ms)), + ("count", SdkValue::Int(self.count)), + ("dropped", SdkValue::Int(self.dropped)), + ("recorded", SdkValue::Int(self.recorded)), + ( + "failures", + SdkValue::List( + self.failures + .iter() + .map(RetainedFailureModel::to_sdk) + .collect(), + ), + ), + ]) + } +} + +/// The daemon's control-capacity read model (#540). +#[derive(Clone, Debug, Default, Eq, PartialEq)] +pub struct CapacityModel { + /// Vacant and in-use control slots by class. + pub admission: AdmissionModel, + /// The bounded retained-failure store. + pub retained: RetainedModel, +} + +impl CapacityModel { + /// Parse one `backend.daemon.connection_failures` answer. A field the + /// record does not carry reads as zero, so a newer daemon stays legible. + pub fn parse(value: &SdkValue) -> Self { + Self { + admission: AdmissionModel::parse(value), + retained: RetainedModel::parse(value), + } + } + + /// The answer a daemon publishes for this model. + pub fn to_sdk(&self) -> SdkValue { + SdkValue::map([ + ("admission", self.admission.to_sdk()), + ("retained", self.retained.to_sdk()), + ]) + } +} diff --git a/engine/crates/layerfs-bridge/src/duplex/admission.rs b/engine/crates/layerfs-bridge/src/duplex/admission.rs index 09ce650ca6..820ef6e88a 100644 --- a/engine/crates/layerfs-bridge/src/duplex/admission.rs +++ b/engine/crates/layerfs-bridge/src/duplex/admission.rs @@ -127,32 +127,3 @@ pub fn write(stream: &mut TcpStream, notice: &AdmissionNotice) -> std::io::Resul stream.flush()?; stream.shutdown(std::net::Shutdown::Write) } - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn encode_and_classify_round_trip() { - let notice = AdmissionNotice::new(AdmissionReason::NoPoolSlot, 8, 0, 1); - let body = encode(¬ice); - assert_eq!(body.len(), BODY_LEN); - assert_eq!(&body[..16], MAGIC); - assert_eq!(classify(&body), Some(notice)); - } - - #[test] - fn garbage_is_not_a_notice() { - assert_eq!(classify(&[0u8; BODY_LEN]), None); - assert_eq!(classify(&[0u8; 23]), None); - let mut body = encode(&AdmissionNotice::new(AdmissionReason::NoPoolSlot, 1, 1, 1)); - body[16] = 2; - assert_eq!(classify(&body), None); - let mut body = encode(&AdmissionNotice::new(AdmissionReason::NoPoolSlot, 1, 1, 1)); - body[17] = 0; - assert_eq!(classify(&body), None); - let mut body = encode(&AdmissionNotice::new(AdmissionReason::NoPoolSlot, 1, 1, 1)); - body[23] = 1; - assert_eq!(classify(&body), None); - } -} diff --git a/engine/crates/layerfs-bridge/src/lib.rs b/engine/crates/layerfs-bridge/src/lib.rs index 3c4eb63945..3fb0e1c168 100644 --- a/engine/crates/layerfs-bridge/src/lib.rs +++ b/engine/crates/layerfs-bridge/src/lib.rs @@ -8,6 +8,7 @@ pub mod provision; mod provision_wire; mod wire; +mod control_capacity; mod control_forced; mod control_history; mod control_merge; diff --git a/engine/crates/layerfs-bridge/tests/admission.rs b/engine/crates/layerfs-bridge/tests/admission.rs new file mode 100644 index 0000000000..e4b421da99 --- /dev/null +++ b/engine/crates/layerfs-bridge/tests/admission.rs @@ -0,0 +1,29 @@ +//! The advisory pre-handshake capacity notice (#540): one fixed 24-byte body +//! round-trips, and a record that is anything else is never a notice. +use layerfs_bridge::duplex::admission::{ + classify, encode, AdmissionNotice, AdmissionReason, BODY_LEN, MAGIC, +}; + +#[test] +fn encode_and_classify_round_trip() { + let notice = AdmissionNotice::new(AdmissionReason::NoPoolSlot, 8, 0, 1); + let body = encode(¬ice); + assert_eq!(body.len(), BODY_LEN); + assert_eq!(&body[..16], MAGIC); + assert_eq!(classify(&body), Some(notice)); +} + +#[test] +fn garbage_is_not_a_notice() { + assert_eq!(classify(&[0u8; BODY_LEN]), None); + assert_eq!(classify(&[0u8; 23]), None); + let mut body = encode(&AdmissionNotice::new(AdmissionReason::NoPoolSlot, 1, 1, 1)); + body[16] = 2; + assert_eq!(classify(&body), None); + let mut body = encode(&AdmissionNotice::new(AdmissionReason::NoPoolSlot, 1, 1, 1)); + body[17] = 0; + assert_eq!(classify(&body), None); + let mut body = encode(&AdmissionNotice::new(AdmissionReason::NoPoolSlot, 1, 1, 1)); + body[23] = 1; + assert_eq!(classify(&body), None); +} diff --git a/engine/crates/layerfs-bridge/tests/capacity_model.rs b/engine/crates/layerfs-bridge/tests/capacity_model.rs new file mode 100644 index 0000000000..c669707640 --- /dev/null +++ b/engine/crates/layerfs-bridge/tests/capacity_model.rs @@ -0,0 +1,74 @@ +//! The control-capacity read model (#540): the typed DTO round-trips the +//! daemon's answer, keeps a missing field legible, and drops a malformed +//! retained record instead of inventing one. +use layerfs_bridge::control::{AdmissionModel, CapacityModel, RetainedFailureModel, RetainedModel}; + +fn failure(slot: i64) -> RetainedFailureModel { + RetainedFailureModel { + slot, + class: "pool".into(), + generation: 4, + owner: "a1b2c3d4:812:layerfs-control-0".into(), + received_bytes: Some(24), + request: Some("control".into()), + reply_sent: false, + cause: "kernel request".into(), + fence_error: None, + diagnostic_error: Some("closed".into()), + age_ms: 12, + expires_in_ms: 3_600_000, + } +} + +#[test] +fn the_typed_model_round_trips_its_wire_record() { + let model = CapacityModel { + admission: AdmissionModel { + pool_vacant: 2, + pool_running: 6, + reserved_vacant: 1, + reserved_running: 0, + }, + retained: RetainedModel { + limit: 64, + ttl_ms: 3_600_000, + count: 1, + dropped: 2, + recorded: 3, + failures: vec![failure(3)], + }, + }; + let wire = model.to_sdk(); + assert_eq!(CapacityModel::parse(&wire), model); + assert_eq!( + wire.get("retained").and_then(|v| v.get_int("count")), + Some(1) + ); +} + +#[test] +fn a_missing_or_malformed_record_reads_as_absent_not_invented() { + let value = layerfs_bridge::control::SdkValue::map([ + ("admission", layerfs_bridge::control::SdkValue::Null), + ( + "retained", + layerfs_bridge::control::SdkValue::map([ + ("limit", layerfs_bridge::control::SdkValue::Int(64)), + ( + "failures", + layerfs_bridge::control::SdkValue::List(vec![ + layerfs_bridge::control::SdkValue::map([( + "slot", + layerfs_bridge::control::SdkValue::Int(1), + )]), + ]), + ), + ]), + ), + ]); + let model = CapacityModel::parse(&value); + assert_eq!(model.admission, AdmissionModel::default()); + assert_eq!(model.retained.limit, 64); + assert_eq!(model.retained.count, 0); + assert!(model.retained.failures.is_empty()); +} diff --git a/engine/crates/layerfs-daemon/src/application/connection.rs b/engine/crates/layerfs-daemon/src/application/connection.rs index 1ac06bef3b..7279b77f16 100644 --- a/engine/crates/layerfs-daemon/src/application/connection.rs +++ b/engine/crates/layerfs-daemon/src/application/connection.rs @@ -492,7 +492,9 @@ impl Application { &self, ) -> Result { use crate::control::Failure; - use layerfs_bridge::control::SdkValue; + use layerfs_bridge::control::{ + AdmissionModel, CapacityModel, RetainedFailureModel, RetainedModel, + }; let counts = self.connection_slots().map_err(|_| Failure::Poisoned)?; let snapshot = self .retained_connection_failures() @@ -500,456 +502,40 @@ impl Application { let failures = snapshot .failures .iter() - .map(|failure| { - SdkValue::map([ - ("slot", SdkValue::Int(failure.slot as i64)), - ("class", SdkValue::text(failure.class)), - ("generation", SdkValue::Int(failure.generation as i64)), - ("owner", SdkValue::text(&failure.owner)), - ( - "received_bytes", - failure - .received_bytes - .map_or(SdkValue::Null, |bytes| SdkValue::Int(bytes as i64)), - ), - ( - "request", - failure.request.map_or(SdkValue::Null, SdkValue::text), - ), - ("reply_sent", SdkValue::Bool(failure.reply_sent)), - ("cause", SdkValue::text(&failure.cause)), - ( - "fence_error", - failure - .fence_error - .as_deref() - .map_or(SdkValue::Null, SdkValue::text), - ), - ( - "diagnostic_error", - failure - .diagnostic_error - .as_deref() - .map_or(SdkValue::Null, SdkValue::text), - ), - ("age_ms", SdkValue::Int(failure.age.as_millis() as i64)), - ( - "expires_in_ms", - SdkValue::Int(failure.expires_in.as_millis() as i64), - ), - ]) - }) - .collect(); - Ok(SdkValue::map([ - ( - "admission", - SdkValue::map([ - ("pool_vacant", SdkValue::Int(counts.pool_vacant as i64)), - ("pool_running", SdkValue::Int(counts.pool_running as i64)), - ( - "reserved_vacant", - SdkValue::Int(counts.reserved_vacant as i64), - ), - ( - "reserved_running", - SdkValue::Int(counts.reserved_running as i64), - ), - ]), - ), - ( - "retained", - SdkValue::map([ - ("limit", SdkValue::Int(snapshot.limit as i64)), - ("ttl_ms", SdkValue::Int(snapshot.ttl.as_millis() as i64)), - ("count", SdkValue::Int(snapshot.failures.len() as i64)), - ("dropped", SdkValue::Int(snapshot.dropped as i64)), - ("recorded", SdkValue::Int(snapshot.recorded as i64)), - ("failures", SdkValue::List(failures)), - ]), - ), - ])) - } -} - -/// Operator/control method for the daemon's control admission and retained -/// connection failures. -pub(super) const CONNECTION_FAILURES: &str = "backend.daemon.connection_failures"; - -#[cfg(test)] -mod tests { - use super::*; - use crate::application::owner::{Slots, Startup, State}; - use crate::{Owner, OwnerConfig}; - use layerfs_bridge::{ - control::{Answer, Call, DaemonPhase, HelloRequest, Reply, Request}, - daemon_setup::{DaemonLimits, DaemonSetup}, - store::DaemonStore, - KernelRoute, - }; - use layerfs_overlay::ProfileConfig; - use std::{ - net::TcpStream, - path::PathBuf, - process, - sync::{Condvar, Mutex}, - time::{Duration, Instant}, - }; - - const CONNECTIONS: u16 = 8; - const CLIENT_PRIVATE: [u8; 32] = [71; 32]; - const SERVER_PRIVATE: [u8; 32] = [72; 32]; - - fn temp_directory(label: &str) -> PathBuf { - use std::sync::atomic::{AtomicU64, Ordering}; - static NEXT: AtomicU64 = AtomicU64::new(0); - let directory = std::env::temp_dir().join(format!( - "layerfs-540-{}-{label}-{}", - process::id(), - NEXT.fetch_add(1, Ordering::Relaxed) - )); - std::fs::create_dir_all(directory.join("mounts")).unwrap(); - directory - } - - /// A real `Application` over an empty Store path: Hello and EndSession - /// need no Store service, and no kernel serving is assembled. - fn application(directory: &std::path::Path) -> Arc { - let owner = Owner::start( - &directory.join("overlay.sqlite"), - ProfileConfig::default(), - OwnerConfig::default(), - ) - .unwrap(); - let setup = DaemonSetup { - listen: "127.0.0.1:0".into(), - private_key: SERVER_PRIVATE, - control_peer: layerfs_bridge::duplex::public_key(&CLIENT_PRIVATE).unwrap(), - route: KernelRoute::Nfs, - overlay: directory.join("overlay.sqlite").display().to_string(), - mounts: directory.join("mounts").display().to_string(), - command_uid: 501, - command_gid: 20, - limits: DaemonLimits { - connections: CONNECTIONS, - handshake_ms: 2000, - cache_bytes: 1024 * 1024, - namespaces: 16, - pager_kib: 1024, - serial_low_water: 256, + .map(|failure| RetainedFailureModel { + slot: failure.slot as i64, + class: failure.class.to_owned(), + generation: failure.generation as i64, + owner: failure.owner.clone(), + received_bytes: failure.received_bytes.map(|bytes| bytes as i64), + request: failure.request.map(str::to_owned), + reply_sent: failure.reply_sent, + cause: failure.cause.clone(), + fence_error: failure.fence_error.clone(), + diagnostic_error: failure.diagnostic_error.clone(), + age_ms: failure.age.as_millis() as i64, + expires_in_ms: failure.expires_in.as_millis() as i64, + }); + Ok(CapacityModel { + admission: AdmissionModel { + pool_vacant: counts.pool_vacant as i64, + pool_running: counts.pool_running as i64, + reserved_vacant: counts.reserved_vacant as i64, + reserved_running: counts.reserved_running as i64, }, - store: DaemonStore::Sqlite { - locator: directory.join("store.sqlite").display().to_string(), - install: None, + retained: RetainedModel { + limit: snapshot.limit as i64, + ttl_ms: snapshot.ttl.as_millis() as i64, + count: snapshot.failures.len() as i64, + dropped: snapshot.dropped as i64, + recorded: snapshot.recorded as i64, + failures: failures.collect(), }, - }; - let slots = usize::from(CONNECTIONS) + 1; - Arc::new(Application { - instance: layerfs_bridge::duplex::public_key(&SERVER_PRIVATE).unwrap(), - setup, - owner, - kernel: None, - export: None, - state: Mutex::new(State { - startup: Startup { - // No Store service in this fixture; InstallPending is the - // observable phase whose Hello reply needs no Store facts. - phase: DaemonPhase::InstallPending, - service: None, - installed: None, - existing: None, - install_failure: None, - }, - slots: Slots::new(slots), - }), - changed: Condvar::new(), - workers: Mutex::new((0..slots).map(|_| None).collect()), - }) - } - - fn connect(address: std::net::SocketAddr) -> transport::Connection { - let stream = TcpStream::connect_timeout(&address, Duration::from_secs(2)).unwrap(); - stream - .set_read_timeout(Some(Duration::from_secs(2))) - .unwrap(); - stream - .set_write_timeout(Some(Duration::from_secs(2))) - .unwrap(); - transport::initiate( - stream, - &CLIENT_PRIVATE, - layerfs_bridge::duplex::public_key(&SERVER_PRIVATE).unwrap(), - ) - .unwrap() - } - - fn until(what: &str, check: impl Fn() -> bool) { - let started = Instant::now(); - while !check() { - assert!( - started.elapsed() < Duration::from_secs(5), - "timed out waiting for {what}" - ); - std::thread::sleep(Duration::from_millis(10)); - } - } - - /// Eight-plus clients send bytes and die before reading a reply. Every - /// retained failure must free its slot, be stored, and leave the daemon - /// admitting a new authenticated client (#540). - #[test] - fn retained_failures_do_not_consume_control_slots() { - let directory = temp_directory("slots"); - let application = application(&directory); - let listener = TcpListener::bind("127.0.0.1:0").unwrap(); - let address = listener.local_addr().unwrap(); - let serving = application.clone(); - std::thread::spawn(move || { - let _ = serving.serve(listener); - }); - - let rounds = usize::from(CONNECTIONS) + 4; - for round in 0..rounds { - let mut connection = connect(address); - // Not a decodable initial record: the daemon counts a received - // request and retains its exact cause. The client then disappears - // without reading any reply. - connection - .send - .send(b"client-died-before-reading-reply") - .unwrap(); - drop(connection); - until("the retained failure to be recorded", || { - application - .retained_connection_failures() - .map(|snapshot| snapshot.failures.len() == round + 1) - .unwrap_or(false) - }); - let counts = application.connection_slots().unwrap(); - assert!( - counts.pool_vacant > 0, - "round {round}: a retained failure consumed the last pool slot" - ); - } - - let snapshot = application.retained_connection_failures().unwrap(); - assert_eq!(snapshot.failures.len(), rounds); - assert!(snapshot.dropped <= 1); - let operator = application.connection_failures().unwrap(); - let retained = operator.get("retained").unwrap(); - assert_eq!(retained.get_int("limit"), Some(64)); - assert_eq!(retained.get_int("recorded"), Some(rounds as i64)); - assert_eq!( - operator - .get("admission") - .and_then(|v| v.get_int("pool_vacant")), - Some(usize::from(CONNECTIONS) as i64) - ); - assert_eq!( - retained.get("failures").map(|v| match v { - layerfs_bridge::control::SdkValue::List(items) => items.len(), - _ => 0, - }), - Some(rounds) - ); - - let record = &snapshot.failures[0]; - assert_eq!(record.slot, 0); - assert_eq!(record.class, "pool"); - assert!(record.generation > 0); - assert!( - record.owner.contains("layerfs-control-0"), - "{}", - record.owner - ); - assert!(record.received_bytes.is_some()); - assert!(record.cause.contains("kernel request"), "{}", record.cause); - assert!(!record.reply_sent); - - // A new authenticated client is admitted and receives its Hello reply. - let mut connection = connect(address); - let hello = Call { - id: 1, - request: Request::Hello(HelloRequest { - expected_instance: Some(application.instance), - wait_for_store: false, - }), - }; - connection.send.send(&hello.encode().unwrap()).unwrap(); - let answer = Answer::decode(connection.receive.receive().unwrap()).unwrap(); - match answer.reply { - Reply::Hello(status) => assert_eq!(status.phase, DaemonPhase::InstallPending), - other => panic!("unexpected Hello reply: {other:?}"), } - drop(connection); - } - - /// The guard is the spawn-failure/panic path: dropping it without an - /// explicit finish releases the slot and records exactly once. - #[test] - fn dropping_the_guard_releases_the_slot_and_records_once() { - let directory = temp_directory("guard"); - let application = application(&directory); - let ticket = { - let mut state = application.state.lock().unwrap(); - state.slots.admit(AdmissionClass::ControlPool).unwrap() - }; - { - let _guard = SlotGuard { - application: application.clone(), - ticket, - owner: "test:pid:layerfs-control-0".to_owned(), - done: false, - }; - // dropped here without an explicit finish - } - let counts = application.connection_slots().unwrap(); - assert_eq!(counts.pool_running, 0); - assert_eq!(counts.pool_vacant, usize::from(CONNECTIONS)); - let snapshot = application.retained_connection_failures().unwrap(); - assert_eq!(snapshot.failures.len(), 1); - assert_eq!(snapshot.failures[0].slot, ticket.index); - assert!( - snapshot.failures[0].cause.contains("dropped"), - "{}", - snapshot.failures[0].cause - ); - } - - /// With every slot held, the accept loop writes the advisory notice the - /// client classifies instead of a bare EOF (#540). - #[test] - fn no_vacant_slot_writes_the_capacity_notice() { - let directory = temp_directory("notice"); - let application = application(&directory); - let listener = TcpListener::bind("127.0.0.1:0").unwrap(); - let address = listener.local_addr().unwrap(); - let serving = application.clone(); - std::thread::spawn(move || { - let _ = serving.serve(listener); - }); - let tickets = { - let mut state = application.state.lock().unwrap(); - let mut tickets = (0..CONNECTIONS) - .map(|_| state.slots.admit(AdmissionClass::ControlPool).unwrap()) - .collect::>(); - tickets.push(state.slots.admit(AdmissionClass::Install).unwrap()); - tickets - }; - let stream = TcpStream::connect_timeout(&address, Duration::from_secs(2)).unwrap(); - stream - .set_read_timeout(Some(Duration::from_secs(2))) - .unwrap(); - stream - .set_write_timeout(Some(Duration::from_secs(2))) - .unwrap(); - let error = match transport::initiate( - stream, - &CLIENT_PRIVATE, - layerfs_bridge::duplex::public_key(&SERVER_PRIVATE).unwrap(), - ) { - Ok(_) => panic!("a full daemon admitted a connection"), - Err(error) => error, - }; - match error { - transport::ChannelError::Admission(notice) => { - assert_eq!( - notice.reason, - layerfs_bridge::duplex::admission::AdmissionReason::Starting - ); - assert_eq!(notice.pool_vacant, 0); - assert_eq!(notice.reserved_vacant, 0); - } - other => panic!("expected a capacity notice, got {other:?}"), - } - let mut state = application.state.lock().unwrap(); - for ticket in tickets { - state.slots.finish(ticket, Ok(()), None, Instant::now()); - } - } - - /// Sixteen concurrent failures finish without deadlock or leak, and a - /// new authenticated connection is admitted afterwards. - #[test] - fn concurrent_failures_do_not_deadlock_or_leak() { - let directory = temp_directory("concurrent"); - let application = application(&directory); - let listener = TcpListener::bind("127.0.0.1:0").unwrap(); - let address = listener.local_addr().unwrap(); - let serving = application.clone(); - std::thread::spawn(move || { - let _ = serving.serve(listener); - }); - let mut threads = Vec::new(); - for _ in 0..16 { - threads.push(std::thread::spawn(move || { - for _ in 0..4 { - // Under a real failure storm the pool can be momentarily - // full; admission refusal is precisely non-terminal, so - // retry until this round is admitted. - loop { - let stream = - TcpStream::connect_timeout(&address, Duration::from_secs(2)).unwrap(); - stream - .set_read_timeout(Some(Duration::from_secs(2))) - .unwrap(); - stream - .set_write_timeout(Some(Duration::from_secs(2))) - .unwrap(); - let mut connection = match transport::initiate( - stream, - &CLIENT_PRIVATE, - layerfs_bridge::duplex::public_key(&SERVER_PRIVATE).unwrap(), - ) { - Ok(connection) => connection, - Err(transport::ChannelError::Admission(_)) => { - std::thread::sleep(Duration::from_millis(5)); - continue; - } - Err(error) => panic!("unexpected open failure: {error:?}"), - }; - connection - .send - .send(b"client-died-before-reading-reply") - .unwrap(); - drop(connection); - break; - } - } - })); - } - for thread in threads { - thread.join().unwrap(); - } - until("every concurrent worker to finish", || { - application - .connection_slots() - .map(|counts| counts.pool_running == 0) - .unwrap_or(false) - }); - let counts = application.connection_slots().unwrap(); - assert_eq!(counts.pool_running, 0); - assert_eq!(counts.pool_vacant, usize::from(CONNECTIONS)); - let snapshot = application.retained_connection_failures().unwrap(); - // Some connections die before their first decoded request and are - // released with a log line rather than retained; the invariant is - // that the ring stays bounded and its counters are exact. - assert!(snapshot.failures.len() <= 64); - assert!(snapshot.failures.len() >= 1); - assert_eq!( - snapshot.recorded, - snapshot.failures.len() as u64 + snapshot.dropped - ); - - let mut connection = connect(address); - let hello = Call { - id: 1, - request: Request::Hello(HelloRequest { - expected_instance: Some(application.instance), - wait_for_store: false, - }), - }; - connection.send.send(&hello.encode().unwrap()).unwrap(); - let answer = Answer::decode(connection.receive.receive().unwrap()).unwrap(); - assert!(matches!(answer.reply, Reply::Hello(_))); + .to_sdk()) } } + +/// Operator/control method for the daemon's control admission and retained +/// connection failures. +pub(super) const CONNECTION_FAILURES: &str = layerfs_bridge::control::CAPACITY_OPERATION; diff --git a/engine/crates/layerfs-daemon/src/application/owner.rs b/engine/crates/layerfs-daemon/src/application/owner.rs index d50f11f664..15a34c303d 100644 --- a/engine/crates/layerfs-daemon/src/application/owner.rs +++ b/engine/crates/layerfs-daemon/src/application/owner.rs @@ -90,7 +90,7 @@ pub(super) enum Finished { /// The failure was written to the daemon log and needs no record. Released(Box), /// The failure was recorded in the bounded store; its slot is already free. - Retained(RetainedFailure), + Retained(Box), /// A stale or duplicate finish: nothing changed. Stale, } @@ -188,7 +188,7 @@ impl Slots { Err(_) => { let record = prebuilt.expect("a retained failure is described before the lock"); let record = self.retained.record(record, now); - Finished::Retained(record) + Finished::Retained(Box::new(record)) } } } @@ -507,124 +507,3 @@ fn postgres(url: &str, schema: &str, synchronous_commit: &str) -> PostgresSelect }; PostgresSelection::new(url.to_string(), schema.to_string()).with_synchronous_commit(setting) } - -#[cfg(test)] -mod tests { - use super::*; - use crate::application::retained::{RetainedFailure, TTL}; - use std::time::Duration; - - fn retained_failure(slot: usize) -> ConnectionFailure { - ConnectionFailure { - slot, - received: None, - original: None, - cause: ApplicationError::Poisoned, - fence_error: None, - diagnostic_error: None, - } - } - - fn describe(slot: usize, class: SlotClass, generation: u64) -> RetainedFailure { - RetainedFailure::describe( - &retained_failure(slot), - class, - generation, - "daemon:pid:layerfs-control-0", - ) - } - - #[test] - fn admit_uses_only_its_class() { - let mut slots = Slots::new(8 + RESERVED_SLOTS); - for _ in 0..8 { - slots.admit(AdmissionClass::ControlPool).unwrap(); - } - assert_eq!( - slots.admit(AdmissionClass::ControlPool), - None, - "a pool admission took the reserved slot" - ); - let reserved = slots.admit(AdmissionClass::Install).unwrap(); - assert_eq!(reserved.index, 8); - assert_eq!(reserved.class, SlotClass::Reserved); - assert_eq!(slots.admit(AdmissionClass::Lease), None); - let counts = slots.counts(); - assert_eq!(counts.pool_vacant, 0); - assert_eq!(counts.pool_running, 8); - assert_eq!(counts.reserved_vacant, 0); - assert_eq!(counts.reserved_running, 1); - } - - #[test] - fn finish_frees_even_for_retained_failure() { - let mut slots = Slots::new(8 + RESERVED_SLOTS); - let now = Instant::now(); - let ticket = slots.admit(AdmissionClass::ControlPool).unwrap(); - let prebuilt = describe(ticket.index, ticket.class, ticket.generation); - match slots.finish( - ticket, - Err(retained_failure(ticket.index)), - Some(prebuilt), - now, - ) { - Finished::Retained(record) => { - assert_eq!(record.class, "pool"); - assert_eq!(record.generation, ticket.generation); - } - _ => panic!("a decoded failure was not retained"), - } - assert_eq!(slots.counts().pool_vacant, 8); - assert_eq!(slots.snapshot(now).failures.len(), 1); - } - - #[test] - fn stale_or_duplicate_finish_is_ignored() { - let mut slots = Slots::new(8 + RESERVED_SLOTS); - let now = Instant::now(); - let first = slots.admit(AdmissionClass::ControlPool).unwrap(); - slots.finish( - first, - Err(retained_failure(first.index)), - Some(describe(first.index, first.class, first.generation)), - now, - ); - // A duplicate finish of the same ticket changes nothing. - assert!(matches!( - slots.finish(first, Ok(()), None, now), - Finished::Stale - )); - let second = slots.admit(AdmissionClass::ControlPool).unwrap(); - assert_eq!(second.index, first.index); - assert!(second.generation > first.generation); - // The old ticket cannot free the newer worker. - assert!(matches!( - slots.finish(first, Ok(()), None, now), - Finished::Stale - )); - assert_eq!(slots.counts().pool_running, 1); - slots.finish(second, Ok(()), None, now); - assert_eq!(slots.counts().pool_vacant, 8); - } - - #[test] - fn retained_store_reaps_expired_records() { - let mut slots = Slots::new(1 + RESERVED_SLOTS); - let now = Instant::now(); - let ticket = slots.admit(AdmissionClass::ControlPool).unwrap(); - slots.finish( - ticket, - Err(retained_failure(ticket.index)), - Some(describe(ticket.index, ticket.class, ticket.generation)), - now, - ); - slots.retained.reap(now + TTL + Duration::from_secs(1)); - assert_eq!( - slots - .snapshot(now + TTL + Duration::from_secs(1)) - .failures - .len(), - 0 - ); - } -} diff --git a/engine/crates/layerfs-daemon/src/application/retained.rs b/engine/crates/layerfs-daemon/src/application/retained.rs index c6c39e0dc3..137129a084 100644 --- a/engine/crates/layerfs-daemon/src/application/retained.rs +++ b/engine/crates/layerfs-daemon/src/application/retained.rs @@ -278,128 +278,3 @@ fn bounded(text: &str) -> String { } format!("{}…", &text[..end]) } - -#[cfg(test)] -mod tests { - use super::*; - use crate::application::owner::SlotClass; - use crate::control::{Served, Success}; - use layerfs_bridge::control::{Call, Reply, Request}; - use layerfs_bridge::duplex::{ChannelError, ChannelWork, PeerEndFailure, PeerEndPhase}; - - /// A failure after the daemon sent EndSession's reply: what a client that - /// dies before reading it leaves behind. - fn retained_after_reply(slot: usize, _generation: u64) -> ConnectionFailure { - ConnectionFailure { - slot, - received: None, - original: None, - cause: ApplicationError::SessionEnd { - served: Box::new(Served { - call: Call { - id: 1, - request: Request::EndSession, - }, - outcome: Ok(Success::reply(Reply::SessionEnded)), - }), - ending: Box::new(PeerEndFailure { - cause: ChannelError::Invalid("peer reset after final reply"), - phase: PeerEndPhase::Read, - fence_attempted: false, - received: None, - work: ChannelWork::default(), - }), - }, - fence_error: None, - diagnostic_error: None, - } - } - - fn describe(slot: usize, generation: u64) -> RetainedFailure { - RetainedFailure::describe( - &retained_after_reply(slot, generation), - SlotClass::Pool, - generation, - "a1b2c3d4:812:layerfs-control-0", - ) - } - - #[test] - fn limit_evicts_oldest_and_counts_drops() { - let mut store = RetainedFailures::new(3, TTL); - let now = Instant::now(); - for slot in 0..5 { - store.record(describe(slot, slot as u64), now); - } - assert_eq!(store.len(), 3); - let snapshot = store.snapshot(now); - assert_eq!(snapshot.dropped, 2); - assert_eq!(snapshot.recorded, 5); - assert_eq!( - snapshot.failures.iter().map(|f| f.slot).collect::>(), - vec![2, 3, 4] - ); - assert_eq!(snapshot.limit, 3); - assert_eq!(snapshot.ttl, TTL); - } - - #[test] - fn ttl_prunes_expired_records() { - let mut store = RetainedFailures::new(8, Duration::from_secs(10)); - let now = Instant::now(); - store.record(describe(1, 1), now); - store.record(describe(2, 2), now + Duration::from_secs(5)); - let snapshot = store.snapshot(now + Duration::from_secs(9)); - assert_eq!(snapshot.failures.len(), 2); - assert_eq!(snapshot.failures[0].expires_in, Duration::from_secs(1)); - let snapshot = store.snapshot(now + Duration::from_secs(16)); - assert_eq!(snapshot.failures.len(), 0); - assert_eq!(snapshot.dropped, 2); - } - - #[test] - fn cause_is_bounded_and_char_safe() { - let long = "é".repeat(4096); - let bounded = bounded(&long); - assert!(bounded.len() <= CAUSE_BYTES + "…".len()); - assert!(bounded.ends_with('…')); - assert!(bounded.is_char_boundary(bounded.len())); - } - - #[test] - fn owner_and_deadline_are_visible() { - let mut store = RetainedFailures::new(8, TTL); - let now = Instant::now(); - let record = store.record(describe(3, 9), now); - assert_eq!(record.class, "pool"); - assert_eq!(record.generation, 9); - assert!(record.owner.contains("812"), "{}", record.owner); - assert_eq!(record.retained, 1); - let snapshot = store.snapshot(now + Duration::from_secs(1)); - assert_eq!( - snapshot.failures[0].expires_in, - TTL - Duration::from_secs(1) - ); - } - - #[test] - fn record_names_the_cause_request_and_reply_state() { - let mut store = RetainedFailures::new(8, TTL); - let now = Instant::now(); - let record = store.record(describe(3, 1), now); - assert_eq!(record.slot, 3); - assert_eq!(record.request, Some("end-session")); - assert!(record.reply_sent); - assert!(record.cause.contains("session"), "{}", record.cause); - let line = record.to_string(); - assert!(line.starts_with("ConnectionFailure {"), "{line}"); - assert!( - line.contains("original_kind: Some(\"end-session\")"), - "{line}" - ); - assert!(line.contains("reply: \"sent\""), "{line}"); - assert!(line.contains("class: \"pool\""), "{line}"); - assert!(line.contains("owner:"), "{line}"); - assert!(line.contains("expires_in_ms:"), "{line}"); - } -} From 20d0d48a34b150a28db72c1817410f36a50ea9bd Mon Sep 17 00:00:00 2001 From: rain Date: Wed, 4 Nov 2026 16:15:47 +0800 Subject: [PATCH 06/18] test: repair two stale fixtures that fail on a pristine v2.0.0 tree (#543) These failed at d2c3f2c97 before any #543 change and are test-only: - workspace_names pointed the native machine's daemon at /nonexistent, which the pre-launch is_file check now refuses (Unavailable) before the name/NoSuchSandbox assertions. Write a placeholder daemon file instead. - sqlite_publication expected SqliteHandles::create to return BackendUnavailable, a leftover from the removed fake-PostgreSQL backend selection (#535). SQLite always has an engine on macOS/Linux, so the stale assertion is removed and the test keeps asserting the real profile. No product behavior is changed to make these pass. --- api/crates/layerfs-api/tests/workspace_names.rs | 9 +++++++-- .../layerfs-persistence/tests/sqlite_publication.rs | 11 ++++------- 2 files changed, 11 insertions(+), 9 deletions(-) diff --git a/api/crates/layerfs-api/tests/workspace_names.rs b/api/crates/layerfs-api/tests/workspace_names.rs index ffa8cba975..0e0c4738f2 100644 --- a/api/crates/layerfs-api/tests/workspace_names.rs +++ b/api/crates/layerfs-api/tests/workspace_names.rs @@ -41,15 +41,20 @@ fn home_with_a_named_workspace(tag: &str) -> PathBuf { &SdkValue::map([("name", t("app")), ("created", SdkValue::Int(1))]), ) .unwrap(); - // the native daemon a call would launch: never started here + // the native daemon a call would launch: never started here, but the + // record must name a file so the call reaches the Sandbox itself let native = paths::machine_record(&home, "native"); // (a home made without the machine calls has no native record yet) let record = read_record(&native) .unwrap() .unwrap_or_else(|| SdkValue::map([("name", t("native")), ("platform", t("native"))])); + // the recorded daemon must exist for a call to reach the Sandbox; this + // placeholder is never launched, because no daemon keys are recorded + let daemon = home.join("layerfs-daemon"); + std::fs::write(&daemon, b"").unwrap(); write_record( &native, - &home::with_field(record, "daemon", t("/nonexistent")), + &home::with_field(record, "daemon", t(&daemon.display().to_string())), ) .unwrap(); write_record( diff --git a/engine/crates/layerfs-persistence/tests/sqlite_publication.rs b/engine/crates/layerfs-persistence/tests/sqlite_publication.rs index 8d0f4fa772..3806e3c545 100644 --- a/engine/crates/layerfs-persistence/tests/sqlite_publication.rs +++ b/engine/crates/layerfs-persistence/tests/sqlite_publication.rs @@ -56,15 +56,12 @@ fn unit(pack_id: i64, objects: usize) -> Publication { } } #[test] -fn wal_full_settings_and_unavailable_engine_are_explicit() { +fn wal_full_settings_are_explicit() { let t = Temp::new("durable-profile"); let path = t.join("db"); - let c = PersistenceConfig::sqlite(&path); - assert_eq!( - SqliteHandles::create(c, StoragePolicy::frozen_default(), &config()).err(), - Some(PersistenceError::BackendUnavailable) - ); - assert!(!path.exists()); + // A SQLite handle always has an engine on macOS and Linux: the old + // `BackendUnavailable` case selected a fake PostgreSQL backend, which + // `SqliteHandles` no longer has (#535). let h = create(&path); let p = h.profile(); assert_eq!(p.identity, "sqlite-wal-full-v2"); From 38a7cac164d7d4c30fab4717ab52a927b2493095 Mon Sep 17 00:00:00 2001 From: rain Date: Wed, 4 Nov 2026 16:32:54 +0800 Subject: [PATCH 07/18] docs(540): add architecture and recovery diagrams (#540) --- core/docs/issues/540/control-slot-custody.png | Bin 0 -> 270435 bytes core/docs/issues/540/recovery-sequence.png | Bin 0 -> 194039 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 core/docs/issues/540/control-slot-custody.png create mode 100644 core/docs/issues/540/recovery-sequence.png diff --git a/core/docs/issues/540/control-slot-custody.png b/core/docs/issues/540/control-slot-custody.png new file mode 100644 index 0000000000000000000000000000000000000000..6a01c53eae29b4edadd4a536d1c991009d58c1d2 GIT binary patch literal 270435 zcmdSBcRbr|-#2cwN>Nlx)TT9x5^BdNO4aH(Yn;@IQMIcjsgc?%s8XXes;WAS8Z~1_ zV((Un8M|g;1d(`hp4WBV=XKxb@4A0~J%2pM>xFzdme27%KJ%T#-!V60KYQsc9UUFJ z@hyXUbaZE6baad}%uKZ3V4g6}(|*tg+%wXnEA1Cpr9H6t-LeUwqhsa%hexv_+<}oP_&U z_tU%hb5M?FO}*S+QfX89`1kKY7pjJ+Y!oqS7?srAuuHsv2H0Hv^1u3v+mmY{~7fs){U>_n^=|vt*QF>+tzpoH3Y)$ z4Vse`cRwGHyNdE?tKueyf4ug2&|z2u?XeugPX3yh(4?F``?vkxiG2OCrlzXy&5@xz zvpCcI1zdHduT})v;Fz*oIWYP0&2t!+6pp!xaGLdRW2toSW7lX5xIvCSDVjF@;jAvI846G zEGd1u_T>wA_Qk*VHXGR&oE{3a4e-1Xx#5BJB=BB*-Z8;mT5x~n;BVdIo{S?4TjgxN zPlq0jyPp=UmUJpZ%}h1u5UxH22bhRO{%wBI+au%Oab?wZV}rj9ItQQMzkOU%>bWf} zx;gP(Gxf&*6l)ac;iu2OyA0cZ{F-ItM{YZE~bBzl0le;M#JQ* z2Nz58KNr61%HV%4OZCA`|H>%+eM_T$x5VLZYhZ1^JpMH~(cO32ta@?~Ob7y-HGZA^ zEvNJ4f4>E^Lx>}KOfiI_atxXH+g zgdy*6yHi{HSsAJyFDJ_|sl=LTbWvvFo7aKhWt|MQk1N7~=2|`9lMiEsM)pTxlF8Cc zDi&oB^`SF8b43Hk{okLiDB1nvnAuz(^H-c?YhaQG?TrBk*+e8HdA+?+JYf~#jV|57$d-2|6ZcVG=T?U_#)4a7AcMH1Rc2Z#L zZ_r5=0#clA2E%bGBO;<2OXVKik`!ixnn-hlh-WwPw);O+xZeH)a@# zq@=GuUyTYd=>?~lJ%y=ls*xN{_8fecipS$O$gG-~W!p5E8K>pusFry>KBsPg-x4VR zk6n{zO0o~D32xkItWe)Cshqrd9!BEx9uQv8kT_|n`xx8pHdZxnw-$OL?r#eGcH>xU zy)f;3D3Bwl3}%2Y`v(BY^tkF82!S**pe?gf3Dr+Q%_Jl#+tVd04daS!t>$9b`Imkc zKg_|ZSZ6mo=99bV&p@``v&tg}DTf0vf5{U<%JfPI-dM6OpkE!+_eQG-r~R7$%jEa5 zn5O1eY*UKZMy z*(De>xq7-#ZG(Cae~{zb_F&XN8aMYs>#u>V`k>9CNjeJE1|lz zx5{ILaw=7=sm2EB^0_R<9RXD-_l7MVt@&=d-m|F_Etg|O2OFU77L;~f7~bCl&{2Mr z9`U14jORduZ=p+h57(0MCX&}2%7C-rHJA zz1f-rI+EprYM3d~WSWh8?lN+xe`i$|M&_p-u+C-bIiJhaP1vpDe`@aZ_jTX<5}S`5 zd{$Bq8UppdfBo{=!sSB^bnp8ZGL@qs2IC)SXuO)vscr~`^3r4)B;2;5!a;i-pNX-nIhK?;Sj=SgWH0M44<#9r8 z=g_(OL46LzJ;eb#&{qv>I|ZZ03PVx+c0h%+nFn93f;2x87Sdoc01pQUp%AtI)hKxv zSG&24$XhV9d-nPysrC7%c>my@qrKNnUYo+I*UC$DT070Pt<9CDe+uvJA38wy9>9>Y z1h;Q(my_FgPHZb>fj?&a zgbTg60_VL&A#a2NdV$(<@7+I>e?vUqFnJz~jKcXg7ued2D^Fa$jxah1J!X-tJtO?Q zQ%4E3JsY{%uZcNe@dB+?Rc+o9;7!m{QsCOonK}Nbx!sa?)FlB|XWshIxcV`tp^&{i zto?A_o6M+hb6lwN)7SeJ3iC2KKEwa`PGMQcOj3>tx$7&BxX+gXkx7_$o6KW`|Gh8NWpe+NB0A2W8PCIm_BywMB_n^l4o6hEPl()>cRcY&Rf1g4r+V`BVVSfTDWbO9ie4Wl&R%;@Wc z_ify(_8}DIg~g z5}Qva6c{J(AL85oU75G#ke8~6BY~(9ef;ubLPh?PbI@&-5XAW9Mu5C6nY*;1S8(@PE6^B$j9VhAu z7(PIxH0_o6UZgxdW#VvhysWe3HaqPA=*G*NtnGwc!e9nfV(_)EZ#pD4XPy(@Y}}rQ zSjwH1EZx6os(aRoV>Xlls9~;ZO*^eIM~3?XV>1fUamLO5$4wDGN=s{r-9G;QnrkLU z_l_5*y91;{Gk$#M^vkBxb#P^n9P=R=qHjw)_0L;Y9UGveu`FX*zd4{V9II=JVEC#D zA=AR`j)ed5^vl0aDyH~=j82!H=FGB^QqIcO-g_H#Tx^+P57&B{5PJVy>TBPl4uV-9 zZt9G1$Vy7~qG(m%RJ{-8qh1yZf5K#=X>SwrL_kLuufzU?v$dW&N*L=r*_u8lpQZ9-YV!x98z}J72 z&s)QD$sd8d1PMw_ncjcz{82rICF8=)TfJ|fZ%N0y{K+>p!T8SojGqRV-suD&pI|aU z>5pYbO(vcc!XMZiMuS|VozC37oNOWPYeNqf*uw8UZdnh%Cu zRKZKdC@qDk3VcH!ht}~o)y{hZ{+BvON~Kgw)stfnG&`$cXv#PCk<#sjZsNH`YWEjj z$Odmi%5q1yG9oUW34Fza28C*bt~!p`mCn!2v|<}_Uew%k!DGyDnxM$B)ktb;AT^PZ zgWc{T5c^sJI_H?c^&fAZdrYw z=CTBg*#(rqEX9*|lq~%~6YL&l$5+@l3b0C@j_+t%54)4O-~WpjzPxLN|D<%p>uTZf zt*HxeJFiH1D5!E@o{3~PEj@zX;Y44sjB+lN*3<#_WHoFOm)}plw3tq@VUGwlv?hV_ zQj;lW3ND(Yqpzh+6U&jcG#8SpE-j!xJi$krP+;FEQAON%SB7%<6&VC6jb`yFUbq=L zN8cZC0sKBG_C>7xz)pT&E86i$X@HJL_`Z2Ia47eO7G%t!;;D^O@C0_iy=-O7l(}Hz zW1}jc$6gO5g2fNQj@vn3ePvT;GH6}NHe@*J2b)yd_IN_|4FuneMDy|OIXfuMYMPw> z51*+JP=S}1mjrA;Zl%-|wwloQa8+6`_sHPd)$ynO0V(qosLfnXH9^*lEpPv=4$}T0 zvAhj_p;{hiZJ!)4cj)YVRY=b5PEFzKk*G+3J>-z*4^QXWNyWWhDZ6ukGJ-_)+FVWu z1ihW(OU18xE_Rso2wSLkEaxod88h11PAJb_>`?sSMz?T)6o~eKIN{%{FXlC41Ysdg zEL}*%1IlT^#7v7OGp{iYBwNhtBUrDHyREe)K&I_!T$4az=3Te@wmD+`@D(QcwkrDS z9rl~{3)!zJna#P24)@xtkRfU37%#=_zr({zSQ3)gx43g2?4T63H$55a}I##e_qBVR;JwBDBj& zty&jRp~v~&VWfuBV+FI`et@aD4lXc8R4~95WV^b78%W69UCU!%#0ccH-{$o)s|j%r zpa2>NkWo168lSw_MrlJUMItdm-7w0U1Lgbup8$^bt$6gz!vWhefJwYV6(pXwQ;H*O z1Y@?Mq~N908>Too z>0eZPaWfrw4*=jr5Yb^6M7!0xznn7!kmhk8(8CwJN@6yRI}0ygAAka4x9wysYv2}D zRuWE6eD&Yy?p_&?u&fYJpO+YTKRH%AqZl(2h}(#tXMakwT!rvjhdbJ%uRFw7?#s`G zrUBF9?-hq|1`}iN1jXGoMd8ET^78Ykb$uUp>m#I=mGb)%d@fjF6>(8WfJeVocKT^fyUUKV z69X^D{D<;FeyCpxsb(h{{kvO-GX$T7WZT9&8QKaR$qCAzLlNG;$dBMX>sCe_)0VC~C7u#6nF{qUeUwgL$LH>t* zl}zGFV~Iw}OxkQ!fJl9D%YohEW){$9M z7L#1#s1}$Lt$C#C9bFC-uq9?(oE7b;dt{WGNxZQues0~?1HgFrR^rw$ zdYp&VwI!&3Jcgh$ZFvpwuJ&4YMn&sd#$qGzoOo`GM_u5s)1-?g`Vv})=*;v;+_%vl zMq$?$#C((&M~(;GldqkP@WHsq7B+478eBF=XRhI2gwr#xRB>nE7pHG(O%Rvhi%yNh z%N~;O`BC6T3;HxDNA98eMgj$^bAhRa_yPj<54?6HyurW4#{H`|&QpYV-U8*d0x=i+$Jptj=7LWvdnQnC?0O2mS{k`_iG6ui|p zCZv?@GgzNt2dL7Y|hXV1$6sKNM z@6Q@S3A?WkdeqKWd-5}KJ}S}j(|MQVSLRf4maLFJWJ&if1shOorjoA%tiD?Y&)I#3 ztlt)}6*nM|vYZJCwxD@rndB=G zT3egDMS}r9-s$WVw}ig-e?{^|JZ!J>DiVM$C6YM0Y~4T&VnZj<5#B!vtz@;++ec|=JdW(SSs6v*Ra--`wU{#EXK0RJ} zb>lR%K3&WsC8CW+)ag?teh&7>3V>~$Y3+1*`RH{F5PHZuvK)?1xtp4K06=Bmc_)3w zeqW(}p6^oAQ|D7R?tCx2tghM&jEfl?=y4A*TMA7c&s!Ew+1h^Zw5Q@ zx!lOR?EUi~&9MBrpo&+Pj?jGN9xK|UJ8wDpuPfQ6iK%p_=g-8~yR`{2;kL6`6iU;k zk8Y|Du*D>$=)%M-3Xx?1apM701O#`dh-Q{1qz(Pa-lRJcOcPqC!P;q$R#XWt=XAZ| zG9O52fu+FLmS@K^-Bl55a!H}!H-WsQwCifg@sV&aoCKFfo*6WH6kKIR)Wa~TPDDxV2RRg z9Wt)E^%iXuC=q*76^g!#kUN|~KiRb1)jCRs_U(ii36QQHsd3X)?ps7|?AC#Lwv@OA zB@%#5O2DKb%e5T%;v{SZqmr6)JO}MQsglGAx4t?i<~}AXor~H!Tu)T}^5<>bNL=RjJ`&8OyI-{opOf*QXGz>sXHkIVA~B zKQAg~srBHc%Dydy7-k{Fcc#r9`?Bh2(R!(*Co7tyc(T*$lJ*iptqAOa2sgt5%;tQh z{<{s9p}z6!9@ZdK1C&l-5Uy@)935;s`z)FIRg1#yu}|%v05`!^D7ubz?P=Q&U?z`) zq~ExspdM$VIgmVUPd9*DhP&E>t5!_I*;P3uP*>TyQsS-2}1-q&{0Afumo&APLEsRE(yY<>Xq zgaItbXK|0!q3m7aVS`1txZ8SvsR;@>dCl8F8iwQ(_?Z7NtR`L@Yo~inRIceXIou2Z zMm|tq@RoTY$r>sGXWRj?lb@-(Mwdrc$<_gUS-Wg4;jVFaWm5${GVV;UN-8Mah^`&v zA4D$|UwIDfeyME+xOQgWUCj6mi5?%I_Bp(q+4p{wA$J&i)W~4VZ|03}R6W;IJsE-k zyn4Y>Zq_}TOj%<(F>*>Dl$Zj96SahaAN+;O{m0*d@b#Uz()FWx*SyaTc>TLmn}q}j zrcv$Kuwu$K+Ye=p4xne!!b??Nm#;!%DQaOpw;08*d-MO<*44t z1)Q}sZJTQ{XnyzBPXN9-7ZAj}%BjuC%q7xW@RH0Gniisn5V<$lbdU!YyPZ`u=lGsx z4X16lMO+jUk#&PrAXYJ>X3%F?tIgU6=)WOFvM^{JvMY*Fz(3t3Oic0 z-(&t9EzSj=n+JAM!c{s|5CLZj9EFFi@bW$5#E_Q8sEY6L4W_MiLOpmP&cq1TPDgbRN0iGLw_)A^dHygP0q^#&# zFE_}0T@vALk3LN_Z2*f!2ufc58m3;BB))&#dm>@5BlKuX!A_WTRiXm>eVAG+zukP- zoZKCpcmB^Z&HD@bmdA_XmkJ(wIa;(M2c7e=NHV9D+&S@6mFffyU_rjzDj)#`co(lP zqAN8E%V=E4Dlg~K*TeynqXY~zrfFNkgTdzx5ojT4-`(fsho0FiBT*PKQOurh16@Knt8PY(9gFEm;p;e&Jl zvH}rjI{#!gItldp{37)3WkJJrNY3jTO7)`Be5Ox^{1t5<{XnlAkKAZzK#cs9M|#@W zOOP`IwB}i6Z@E zqawXeE4(ag~TO5-~KW}J0=tXa(5 zn=?4Ip&F|X?S^LDaatR9ZyL%mq*=utAwWSR+dbs%3;7P;=Xm5B4L!`?egvxfl7 z{s>~5FqAXlq8CB{wktBDZ<7w^T+T(ZTrIyVSi7tcHbH`j z9_xf8gJHxw>$d4H=%ju6*NaYn2D%9s~nnrKX`Hq5DHF+|}A<2)80`MmzHNa}ZC z>5`%HAv|+oX4x^M`}o?e`$a#OKY(+4{oMR--l9D!2836#T6+Ff(Q&p`29?FvY|_xYyF zQCa>Cqr-&~rBMiftyZ=-<*HWFkVD5M74!o)QzbG_{<+9&XiK*n^0rN4S9C-=fLBRtVDMUK&%3)36LZWOI*I0aL}l1Ns?H4c%kMi09kG9ju>Q;&$4r0sdJuo zvkYWfLuK|;e;y8TlzkTJx~b%%0A6Lu8lwk>lI2Zq_w+1Hk@bShRZx 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

2lf- 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

&UL>A=}zuczHRcLY#aSj>Ya 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 z%0AO9p@iBNKSNSZ8h(E5KFH!J{?0bB0K5ybf&-0G$am#8DJW9kawNg*u<$XAF zEUr;b#dVi&ji#K6>-%NEmSySWZ%h*-%@|geN`h6}QP?I6nYX}hhoM|eTDvk7HzY

OmZXr%5;%IX7IOX7d zG4W5dQd~5t%E2{(o08ibk;fx zkztf^hH*_)P0-Jd+sXFb5tOo*%aS$}Yr_o~L>Cn^pWqQ6#DjJbwc5(uMD0Kw7=r$B z)ks{pf*wZ z7PcQQgF2R{UAKQ8Q0H%I?VEvj5-@r7TJ3E0PSoSkz0YRxokbqbr4?sQ?SCtoJz_cufbu20y+3qp9xj`60VeVgh(fqE;Cm_3oopp~~4KSpuVY z4Gra^V&Thhdm7Y~&WnyH^3GVFbqC3AF)A7dJn?5LZG0xOn4ZdJKQZxtg;nH(>p!cY zWsw>V)JGC)ABVCpe!;5=+cX@Su924?{3;eMD|j7*i!PU(JTvoX%h;ZI-9eUER`f05 z!;yt$6tvo0~e$Ts9Gtd@|rw zDJPLc_9qqGKJw&7oxLx$J)WGj>=eyp3PRB`(>z`FU z^rpa*vU8bujfI*%#i+mIYql;oIPt2NF*M$2fNk#`=Rb z*4pc>`Of(~&z!GBX}pmbZ(Q);5Ibs(SI!MyqGzZK#<7O&Jd#qmFDSUqf9m*XMe%u- zf)+Mw(Jj?-zfICkJUMRM3aH!zdwXYG@JTWJxxgKDMQQe)#FbywX$qRFOr!L{{l?4) z0jS|_>|(j9!gN}+TT$kUjMfip#(z-JK4^s$yb438S<%wmwD(qjU*UMh@nvWW!4xMx za@#5FDd?Qmi;%8UHxz2({}Ez`EQ5mU9!HGB6!ux$^&7pJrh)fdni``VO&HDc0{%)2 zVqdT)PYQh_-iC~liPlr$Caa5Wfg>8Hv9cC>ci_y?+o7#E&ED$Ku>GL+Ufu!RH7i?t zWR2%L2!-KVA3j=iKtefm4#MdAZlfzpTZEs4vGomNZ9AEqkRgSI`RlKttbL5?d>WRa zdBZ`cezq>V+7p?^-{%@_#{WxMn})GM9R|#3&I(Mu2+KDcf_Cw}l;ED;^D3jZzgC&Q zw#pT5mPZUx5f<0#arPpFJA7QOznvLMyS$i?*_a zd!_k_WWy?WWBM5D1^pLzqv`!0?Pdr|UpsKa%-n>0_fzE$xKpY~1i+7F^6HanE=(2i zVk1NogEs3m8@Nlck|oC7qj~<>-rB|ZOR?DQ`4dIT<`1T+5ZH-o*u&9B8a^8ADM1EW zmbhL*aGho#av=!!)l;j__OIz8UfcO!?Z5Q8KdLJ&)S+F)VYDKs!9lzInXli6Tx9Mo zscU z(o~1l{65tCY@rWY`t;!)?2YReU|OTGqNNXeW=ebvnjX4E(#yD0y#J_-A`0*|t3l z(fj6UJ8*Ks9uhZa0nf8Qno9yttR4=3;-K8q*v@|skyfO@_X7YxH)6nANqUVjN<10DzO_lJFBh6?z2{;|k1{9ZmUH7odn91j z>?+Gn>?KHiDi&e?9SQek^^rVd=`${RY_N=%_uGUkiN}oxMKXVml&Yw2+0V*i`oW)` z(joCaQFp}Qz6J8o^w}z3``+Mcw4((vGa>RKsyhHEC>w@Q7@Cj8Og*-bGZ7x5%%}db zoSEu8N?;FP;ilV84C-+Aq&2|_2o>RwU06>~i=)LMj>8BelcUTXih`PX_v1vNZpdqX zPpHRV&yGRfbECC+L6tu)-(7pR!u;8xGh?;sdz|m0`=NfCK1fbhB=42C< zm&a}NUDK_;HaPs)^0mY33N;GuT-A6kv6r07`t~PeUvT)_-i#5x*r_jf5PuJjOUGF& z=z`ww+mu&OPy%#9w%~@l7p`xFH_{D9Z>YD?kAaXexklp*1H;GL$dj2OJ9X@a2xzV` znpTwTk2ikF2X%SE6@uB6@66x^^8kTce3j&^^J&?W42yo%mt5X`Q9Dn|US&`lE`D=I zvjzy4IZ++TXahOX4bs>XfjsP&#t3@_xT;VHvGFM%#)ff|8|Cc0cTCRnjdlt3*oKZu zbwqa;dj!x;9+l~WE*Cs(TW6otohymHnDXm}PwVm9dW%hay|;vt3Su&x;69?D)}i@8 znpWzVUj}|nj!fc={_zs7T5njPuIl_J)K2C%rPdK_4dnoM(BUhEzU$1YT0PeG4dyIO z0DhFcG5`IYr_Pm#Wb$V*;bmu~F4d@a`d7X46*dICgK_0X?0?tXUX%MXsP zSd~qDkO(()zyflKLNWMzpDQSH$!P7SGw3L*A%;a^QYiVk5mJ2*1@=XVgv;|(^*?b) z$=ukRmrtYhi}C00;{`ymshSry;YZqw*}O^p>F)l*V|Qmv)@{TE8Hnf z+E_w2doJ2%c;-bvie>*kx;hX%q%!sfrpI+JbV8ZCqP~@YV#xX9!F;4eYf+b9l*ZzU zGv-Yy1QH2(SzF<5Z?fc3(f)8AMS~`zhNG3-FR5YwYUvmBGayYk$^8yUCr{>J{u&CE z5?+GPp%gz_D3UvKQe`Z=nv{rRA5Be4be1c z$7<>qYSnxCDB^AWA=$FB*XD23zXApBJcaLLwC*rhGDpB?FY9oTJD{vKkW{|t=IVj- z`S5_nx2(Tl6*D8#06$QVjKdgq%I9|gu(BOVQu%z{#SKe@Qk!1h+@k=$E|eZNA(Y(K zq!DW^X@n6t)+mq}LCZr^Ho%ZlE9%5rbUkuJ z=M)Qiac?T;sn4`O7Ssq%mWV|fK^Qg)vc6+QI3*|BW*El+&ny$BdOq^sGyA0XL>)DMPoY0&u;*K zfy1D3pW^Q$Qmjy#5^(R992J)1}#urOt$#e)8$2_cJaY0 zxaI=*AMiJ37nIUn(LDckzZ7Z-U&8By7#mg|?H`UL+zCYSn>W4N0!>08Yc^K9!Ql%n z8!Qy8{t#yVeE~CIir_48i9^_h*RdUM~AF$mTG1G+;zl($45~D0HdG-B9fZ1kC zJiOodA7zs?PGj`%1d`;oELMeT>QX!PoBDXRW9>Rtb}KfUs+CLz!h8)ktt@R=N%x1| z$@x`h{RVNIFF*}2nK+Ml|EtEmg6{GhErQnM3#@5F<>AUha81b}N$?Sp~>KwQyJ*E2G zVr@vyIIYISEp#2fuh#QM`@qZRHJ#mjRrK?$!zIH8k*!iKe#bk8(&l2r=vHaW= zT2me@Bl@ZZwno~0Vnq`gXp1e^Yak0Gz$A2Fm`pJel~8PQrwGp5w0{jXy8{ft9ZV(Q zZ!`61Y-sIv?g*`1Gk;u;s9k1bA|Owj77(wt^YUTS75IlYgcg~VEylLE$at& zhT!Qpxn^ovN=FGvHot#)=c7@$xY4?2CmUm{@r7_%mq1KuA*7P^bl zyXJ}JHS<*WV%zSys(MCtv>0QFxt9W4AIF&KLWj5Hc?YZX20m(SzVX`o>dU;zRKZ{B z_r`*=3x?BDvW>kc?MFs$iGPtGj7~H@AS9poo}w;+u6~r%*+PFYtztSmqO(_MjQUQ( zV;zT5(tV<_Y=MdRr@F&!lEBWcz6#n+@q!6?RL@DJB;{E}K2_gUfOFZ1ocC(*m;P#! zmCy>G%lh)g60@N&w2`u*Emw-iAx|nF!|U9cMH`D&?HPM;`*`m+c12?|(dG}|X96IN zuE^WoOYu={Vku&u%Eo$ud4&Rgh}R%Z0i4X}s#Byb3b_16D8G{&P{O?pgzk{0sh&xAjA>Xw$`PRa7e zkV+=YQE#$-*vn0d)Pu!jiv;|jMPBH)mmden@Pfy7Y!7Oj$T)N58IC-B*spp?#nCR7z!n3?u?(KAwDA$&o>O}O>q_O$m*~$ zu_|MbXlhOlgPr>ihSXQ;DoPP?3*%bj64?dIwl~Tejf-oL24~AZ2uE8^*fab0na>f8 z&#YL)PEOPeHgNFMM)hn4Y@m9Q4}pWM@I7B|bES?Z5FSa~U78v7RU8U8#s;&FAmxiM zjOvM%55ov+?_{kv{_y>D5D#MM4Ql9wWQy33mCjerq~Uo_|9mOtUMyH%fo|Ww?D(~H ztD#5a!(mES=&7)L_3@vJU!G+S4|CixZQ?mG5OPsR3Q7szpv5(cB9Xj@;BN||hxl6_ zPo8v=%%Y7Dmm%dv378gVmfE146ZeJNygyCJ)|2D8w#zU!m@RemUk-*)xij1*?@jcp z{#|)Enq-}iz1rZy$zy7TRThZohRPG@M>iq=s!2n*g(1{7tj_lvv3Za#KEP!E!m&tC zAJFg`t{3qL(btevAOuhD!|~GpSZ^8^@-;@shc5nBWlPxj0$Tp8!AYxJ74h(oSX69l zd@S@-%TM;mPGiiw9KJ8z_!Wxi0$n@KgEyVGaL>ZGcB6zA9LFXXo=csQ zZgDfv1hI76>c9G!UW0}MQ?#a}xC^?+g5M=Elt9a-K4HDVKJt{gnmgPE?Smg}uR@)X&tiE&I^}b}BU0ka zNUhSN7rBjUf=01N>UahStrE2w?I^yAWMK#*ddASy(5leJ&?YWM#s!D zM0Iwhc))wtT@zrQe-P5#$7>{Hsdh)kQ&;6$Dg`ULe}AxY})S^VwZ)y4d^ zme`|ya^&kbmS%vr);SE+><|>FYkkw?PZ0prZw3OBy}Zmq{RY4u>PSC*BKB*92|Tke z(iP`Rdb!_-TxtjmSTQJRX=i5~7DiTD#{A#1JDEE5*#*VLb!-h&*|h7t8r**2q-0`N z&)7Svsu|bBYf|;^aRE5S7s(?Q@t99YQ!?AHj4|&Mwit3Pk}}>(aTN9IpnXV`#>`a% z#mLywrA@2sT}FHimwIfUNNnk7T`d=BCLpF(VE6?_hAhf40In~61YM) zfW9|CQ%jUa11K<15P4g6)JB&OkD%hB9YJQ;xt98$UE&?AL8S>g8RGcHxI!Upp^r7C zxI>KlG*!5%Q5U)UQM2@$m5rYqu?h>!(5|kLn{k22c@}-MTwflQ|er>Xm<&tlT?(UQhrldz_!hg=SZ6)pXC{;EZ{-cSDW;ATICNXJEWd)Cy)Vemmdh&a?Hv*mZj4(Mx{S(p3G(1eq3h5zM z+AYO;rSGZs?|9`0A6$bws{jvMh>mIe&)&Vh)SJ5e`cFp>U9so73%I_kUFx^l+QDV` z4c}JQtaSYwGK_Soij!`T{}qd9!@tNI{&GVMcQ`O$?M%sJ_mppS?ryNW=Nb80uto1 zKwyTb&a&-F5`(O^;Ef$jK1jOkgTw>sJc^j2DzOcH|CxUpOFv$AVff$Tc$qp}sx9OG$lr1poP#a`z$$Fc|2-zGy-Xe6KQ+k|7giE`TR=1cZ_KX{Qc~ntCe|Li;FY z!^ZHDJH+3RqVQT%*|?6#{|_(z73SlMqf{r*{kT35kM@*J<+<<=>okp0!u{OevA{P6 z??h&^i5CNg-`fLRAV1*->5I$<{E!l0;s4_pX?1kh$)qL6if?~|9hW)-!uNu zbqQ!27h-4N5%kbaJw3ct*NzyF17nrPCK-7D?@DOiZRawxK`zYaI)$iE9W{nd5NIek8a{^)Wf6_<O-)UiKUSm!l=$2(!E?w;gZ;S)l}^^ypT@VfJp`=Nj^BPV z$LJwg`kAhWC8N{->3e>{N46rn>1{0!x1vwrUxx#t1WDYpA9bD$e)^s`@sX{tsd%{f z^iUIA_-hGJaTP26=&wZXc-EcB{8sy&gqFap^^WYW-v7Trm%mN&Dy;Gg*4vJM+G2aepKzHwE}6u1fW)lfbe`#H$S@1a8m?OQ_glX|w?^;i~` zceWzzB2pVcrcY(*%sq$7O;ggU3!?s{_P1Rydo3|l@l@pdHG zXm;U!-Jyj8vB??j2P^B8jn{qsS&>h{_nxhExjy=Jc8k>e_=?1YEY%)!Le0f72ABAU zbzUWv;qP(36-B%{Lz7GO)nw)Ux-P_=k7Xj%l*UJb$C5YVlP*_&GWgN7G%#k$Q*i$D z?7*tN*2Xvr^Op*p^vlN=2Hpc@jkQv~6xS!6Q27ci+MV?Eyp$Z=*b}Vk+H0cMqad}F zAeJ$BzQplMXO`)-1~O8MN#@!dv~B$9`&FI(A3j))z>dt$T>8T|0fptfE!tuJHCsmC zX2BGg_bUph+iPT1(fDEY>1}6Pv79|4j3YIP*HB;ivB(u9%iW|`{Cpot?fRFMy_I9X zx)1B2TQ)EW#hcZ@s@oor?fxt(RITew^dG$4OTwp~1XOr=rH-ftcQMU4GjFRU8h=4e z;0T1-`4tNP#vShwl{+9nL+OzCJNI4S{R+<$sTpJ5JeeT0(Us>iZVAwsta=&1>LOW} zYigC&Czf?X-}l;T2jromT8eGe-|7NjEofwZ)nRVT5)%yZV^EH!aZtIv(uO}mjGX9= z-jqRsU8@>W?T@jO9r=k_W+f}*b2B@t;A4xmEqO1`cf880%7t`;w(2vQs@WOjvgMg1 zAZPs9I5o5HOmrx-@2wVyycTybyml^AGRPKuBvAT*%mVG`Eug|f_k`RE~(&)3U|3i_triDCm5{@G6{_&WzwjPFGS7@1Z5|6xYXX9Eoe!4PHbF`E+~DOOV9v_yi8z8}T39G}%P zB#JZhS_e{^CU?0bO@&@o=slo~n0++ie3V_y)-8qKyHEeR3n6@#@TobJ)VndGd>Ak+ z3&Q)6{7ZJZ0j+tKZ`uXZ3<O#FK5_L6bjO!sXpjjKGOXqukLsO*hn5J4NLcbf)Yro8q5irf;n@)ORUq z5O0Skv&U}-ovSa{gRT;jrG`B2e|!dt`q#D?i&Heb ztcbYHI8r{n`#H6aX|tG^>vF6XEtiB6jAB4|^qc6{!56hQ zJhTf-@0)e<$}Vny$9`dcK7QuR>^Y>XKn@(%?om7}j1>1chnhTYFYQ}V!&S;qrE1X8 z@L%0OwwUT6mQuOzH#TteBuB^NUI7TW;8InKtw?dw2m57oy zg6TULKtydXh0;Wv%a~|`v&`DRb6Z|D4lgw9+dTN{abQWrm4{R1SO|T)ric0&5tL%H zO^j$6ue%+{-i@NDKSUc}P&^awD(hBwpk^~#BV2&&E3b;S-8$Mi4lt>*ptnSFLQroF znY7I%UTG~Ag6y)JfZO!KEVxy2YbVKwN*mO?r*tU~$dQTRe ze#xoOC9_#{-n<}_R^^f9N_p-vJ^&ENeQKHQ=Vt)$dD**YU+E&@@bJB+G8K;tR zdA&Y8=3yRLVrJ-d^IPWeCIIyEla@YYEREB~lf1^BPiQ5WooGB+e9?pQ;_TYn-r4_K zidq}V5bne_?@R8u-~WMQ3b)^jM+3N#8}+<0{!i8Fkpo<6`z-IgZ{XdA)V`1~v(Fnn zjw+ciqX%iL$Dj8(0%!oIL0#Zm;1JkoJDTzx&dkw4lD4x4^pRg}Ck}V*I&dcia9n~{ zMifNfHgWj-ekF&X+B!GT!2RM;8LPq3%k4W58$kFN8K)FXi+;_xqqc0n)+{yL6$iG1 z)#URVuYT2-yXYv@G35L)X9@|o1S78_J2uXPCc3TzZ4_u*YF$4cEP%-?D9dc>4DW6^ z1FguWwLG(`6>;;%e<=KW*IvT$eA2CpF%|S?-O{?@=8dR@Z}5*gfk_)?N!rJ4_B0g& zFKVO*g^7CQs_F|47sU2D zT8)nTQaBb3&{{^H6OUKM4eH9f@Z|d1P`^B_EmHNC+NV<@wko7G(sC&$^~omjrT69O zW*w+KTKtq$jq@w)yBvAHN|-k2KKIk6U|valMcfaTFZ^6qY#Rh~aqBFy`G+w`qMi-( zxqR!EebQ=1y*?&fv=wTocVpG_ldKIas_b1nCXaE`Bs-~*tsHZ-BjeaXXAkBWCHF!u z1A}*1CLlyJzu!X}59Z)+bq5t{t@u&Gx2AI`9FuLC50pJ0B*KM42(-_MF)3e0#rp5$ zyt8AdSoL|Dd7mb6MP3Y$W^j8r2gDp>Y8MX?meW6Yz0B8y9XK4H{V)riw=&lq$4DoD6*=6;-F zvS|zSra!Ni+azE<$j@0+L2EGD1YJ+R(Z~&0inWur_HX4Y2Hli z>fJvx&wZv@j^Cr7MO6Y_T-i$Qr84A;LX6c;N%;#08(yf5SrL;*P?ovE5)uq`%|r8t z+sGaIqb{ielKYmWGyNq;ap&=AjpxhK*T8fOxW}fRh*XgH9*%qQGMwe|H4#(!4z;q) z@s!Pu!LCuKlBq|T_}dsD=pk=#ppVN_tnd+DXQR9l?>!$ggK?CWk}4YZgYvmUJT%oC z;u7T{7@pxQrW~?jGMaQUbwF$w;7B^jzla!Lgi|voIfFYNVJ6M*-1Y=ox{g0yT`*cW zveQQW{4Q>h=4CY*{w6m}Mx(euCtqm=5~+EFHuP*0fd0~H?V#mGtB~G0FW`WUYTkVP z-qzC=K$cSbB~kmFw2~~r=m?25GyaZrFm4@ZNjF4Adn2e@Cy?a3alc=FNH32WbktdfpOQ0^%$D_%>f`F#{ugLIvqm_uKi(9c`=>Y{|GkxdOF^PoQ>= zm??lrM!xIX!pT4^_RUk$`|_)2F7$0l+9*jAp`sd)yAI|t8n-Ttle0E0kEd$@;oc*m zKrxg%IPZSzc`*|L@`E5lQGZH$hWB9Jk^dGCz6q|N3@_X8UGqf6jXJ>LuKLcIWn*uz zk~_EzUD)=`Nfh@A+>4H|@*hlFHm`t<)x6J5z<`o}+B_o$UJ50CwbM}SIPj@k~PVH-$ z%*m$1G^xa|4wRe)2vK9o?{&+pgMZknXqtt$&!j+}bnkdH5b4D)W?B~Y(AK@HwvXD4 zPN3Bu(|E51qZGA3BXpU(8l-KDkK(TlFmoabOfKu*?=TTnT6^c~uTFmIor;y8wwcGeeTE@^G=3FghsA3T z#B@aGB=Nud9$xF-m^~e@okP72Z>2S?h(Y_9Um>4Zjr5lma+$U#zt*CW)oiw`!x7I9AO;X%Im9Q$XtF+`$tA72{rPsPP|kVLl+<2rfk}~a!0k?DdonApY6xabX_Y=TgCOF z%AfUhRc&@#xkKE+FNQ2Er93F66X)!BS{OXVT1m~#tZQwr;Ft7TIS?0_B`A3X%DFl3 zEgZGgjRada1(O=VYihzS8rDo&}DklwD1|-wky*C zc$n}@u~z07OOvTk!lkVptYli3=|P$>%n%bff)^TGc^r+G5?FJ|owL|RG}5G5(qWif zpJ3tJcZ7Ox6-O^we@7T5s)=MNP@hzTu<|fh8&G*lW@tlOayb{JkT+7@=*yE<7Bhx$ z2XLlI@b}M%d3EjBFD2l1LKNbCq0KM|PK=^}4|8m}KTUS_!rjxOr3TSHdUi<8M$*|= zCikE$i$Hru=wg(?g69E-ZG(miUdrweyxQd{5{RoJ1tW<`VHF6lo|)uQXZpJhIMYHKy~aQgL6O8OHHvyn#vVBrDc)T%`mXm5luQ@L99At0qND?lJwM;P zat-G{u%!j;>;F|rC5(K*z2Xxg==ob05z0N&? z^XI;Xpkcp*%t7_0FvQ-MJRa^Mj9PjhI9kgiS&Yzh^1mu9_kYoQz;bWHOEJ*Ph>xvGbqa%h-!xrOa(9VpU9^O$-++}BCwh8TxIrud>K z7tJtlUkfjoVk!bBIPMyo3*mTS1Grj!=0gjKPtumDx>Ya}RdCkMz*Tzk#aqqXOi_1> zn`n(Y_gDwjL$tDvp>}q*9kzb5f4X5FD=cQ%>xbF`mlI^-Mxp^_In&Wkuowj@5qQon8u6ujQKW2M&^ z3YUev2o;fv!l3&?UW3J7)4Cc>=)M@ho`~P9=tNr@UTMv#hk%g9cU#MqMTpa_$QSE% zmCpv~heu2KBM`nFUUT&3kMjU&zY zE9mQ=MwTyc`x7YbA6xH?ET0K|Rpu^Lo!ACBV4ZS)G)&*Vm?8e==E{ThjH>*PY>qo0 zY{u|zbBW}yd3t9;E(Ne+O+_x1Wz@<5%41z$MIE+H=cgO>kbTj{_HNb5RM zlaz+%o9}-+()4Nz>^TU|WuFlM($NZUjZmh=K7H>>{bjWuEmtkRN24WKwu80|%k@W0M}l}y3MIcX0L4~xrU4oKCRo6-6erT zvuGj!ily@u4~M%bJ0NZ2*lKH9YM#)L7l%XL6w zkCc>(3RONjnRPBqpcrt7PT$0Kw=ajwbn6>|-KALqgA|}_VBJLPrJ2A@Y;7w<8eVeXoV~uA zPVb7=<@vvQ1xz5{XcbmZ5Wel|{g075a6M#bfgK~LilCPTB(%kk`<~n6r&VF#@(0gpu zg5>Ikv~YO?2w6@hzp&WFrVo}L1oX_7bY7eOaV7c<1ZJP4&a`6g-VvFzl9RoNPavD{ zgd8aIvE&KIPJG%KTfNv2LL|v0QSU0Uw{7EjU+(H_m%;35es{{78?3gKW$*qN#*pP= z*XnAJWAp!_WI(}-Lg0UpgQ9<3KLM?wf@7TGIFLneDT1RVgW}QySa3(Rm^C|h=xn#6 zk_CstOgFrI2N|wVDsTElJ*Iloo~kef%ENZyDC?FR5l{qVY;KTh1{Ou*dbyyhc5s)_ zKkOp5L&2?9FB01(y0ik@*w?T$6osNw!of*oX*fd!P%wbk0Q~eXpzhRWdGWulO+c*; zPx$BG05s0QTiEZkWRPwCcuMOI|FYsFg+8GwZBjh{4l!xQq6Vl7>6dO@!1tFC>(ISE ztIeK5ei2I%tcDi>a=a4~^mMv4Pv&MjPhBs8(ji2>x@BIP%I~LnF5|(o93E}xX(Oif zEl?ealCA1d& znpi797{B1~BV)p*iFs?UBTRq4jxm)fyMJ>3MRHVHpMJw?E6}@YOjM&kN*bxFo!n7J z|5W{{tKr>fTx|rRH-O!8V59SwgEjv9N>1mWso?c4=K2d9)sF=dO!ttC%^BrfWr z#Nx_)B1mrdT~ljt7EqK3fG7js0s$4UME-SM#(^AAtg~rALal(R68|t#T!5w%&fYrE z0_z0VEDXJXJTE+>k-s z<%1M!)~;*sE}Qw{=~NazT=+-J!{n)k=pHo(C2Z9J z=nj^?c#70g&Gx!jFpzps$B<)dqY*afScBTjd#(67ofm{`_8iA9$~Ed8C7+b$i{7&2 zitOQ8wj-kr!qQ|;4QFD$65{)`rPe1B)_aA?yIKHkMK#z zYJT%2#SzvjmfROj(>)gsCzcn$aP8a52=>{=of&A_^<0RP(^14M;osT zU_*aWjQdr?W%(6AC7{xnrJR33GYF?$j~B{jx1q4pPH(YnMt8rDtOymK`%OU6(%Mo& z-!T{E2$szt0b3nS6P9x@m6$l_&b|lNqHl2;iiKszyJU*E-z*BoaU?k3fY4~27wvhz zlRN~F%z8?)*vA?KyTh|qHX)ITwJ5z#VB<H@58>{HD43$z>VtS4=m_#LAH&0_)gWTVYM zM%8(X{ehosH^*^JsssxEor3_@T-LzNB0#D8w5_9%d{F(o+mh%SIx22NqPJ>n>-)Z! zXpZ|jN%JbMFMwF&_am`R_gNLTuk32>(Pul>P0y+{KrrnjzOd%`1rrUY=~fWOiFlOZ zGJI!$WQ{INERgX_-%<2B5GU%*qdo(MmC1a>!%@ID~>e{!H9$kC8#$PLHLm z6iJasS_C{FSm;h@RI&~5WT{$%IW#nbP994ms*H%^xY*K0h~l#5P(Oq$Yvj~%K`WXKMuMJau# z#2Pr|;IylV!ln`Jpm`hNbCnQ-+dPB>iGtBI4`0cQ{{M&KT~eECEP3JjC)f0=2~k3T z3aZdM)AVW5WIuV12T&jY7X~P8=iPh*4vWOj+lZuS&jf24f8{jYA8}u&L za)$nnetoj@LES~9afi9O28!8lj$%0CyBL)(YZmC5X`wXcxTH}$rft0vQ8W{8C~ugv zteUat{CVUP+qgV6{!0rW&5$SAe+0<3tMYkA2sf)Z&#-V~okLhmoHNH>f?$oPidL~` zdd&m@7Ua3tjzFCsZ-PO#gMiX|)s|{Ry-0J=hD>`)4edA?VPwBavu@xWWQT+Mi&QsV zdVr@GdVYJK`(Q_jYucG8SO14=NJdDaJehBeIPY_y>;$pZ)U}Xy zGftrSXa4Ch8tnrFt8A@CD-^m2+OD&cfEJ5ytA>E92uv?2ytjM>%|&IZdLS2>bXNrp z^<_73*=InkQM6BXx9B`NUhfFjkTFfr22+W1`v1x-&&f-bwAnI&Z9OIPE>d9^bQU^N z(D%xF#eOqz`-;6vXN5Gxi*S5kOjN%i&jA&Zo|LHy6b>`C+OM`sOilVRT^GvUZ*0gO zm$5ODIGO0I()vV&&>!zy8ZZbX3Go$w$a2zdg){jfG=kf3a(N^W-jLxtj42 zA+toZe0sjKsW*1z44SYaB>qkNgYEQw<}3e4T$kFt1nm`kz^*+9=HPuZ_ShXIxhE-} zM`v|7zr~ptnW&>-Q=og^&c_I)*y(|$FMvu@!$T=i`_s>=BLbW>KzTbeupIDj_ESyP z8@j9%@m<}l)%xwWN*SOYzq00X=YQ8S(@6er$pV5Cfec}M@$I;=T)woQ38lZ(0bP^`Q6<6Rn%5iF?~>rJ zBTky(Z}{Rk9$SRc=tIZ*>Q)-k+TYMD^XD!C5ULY@NknoD3f(r2Dkg5wt^|mK{s&v` z2~EU{GC&VhaztyW`GM*)i*(S+z;_KI*`q%;pV5pd=r@I8P$mq2G{HP9*kNy*G21QoyJq0Eywqje<5VE3b><$8mdxCDG2SconM$WNq zp%EO&n+AadTtrwJp}j*BYDW8_s4q5&!x{x$H7D`mCK(Ld?rX87ibNb`S~>}P?&ocW z2Y$q<_Bh)HGAkdNH7kj@Q>E%@Hv*MVqP;2iepc91q};g)4U9eSLwO%v8-|(XA{Gm) zWJ$}`3p11#POcC)I+W(GAS1ty<|%N^*};X_0A3l={B}d^$Zcj_ne4;sjN_adX961m z+dO3*SwKA1O}S|=|B(rLH``Xr>vM~Sj?wg^hHvugIq^B#BTo}kiCi%fT-kAe|3kka zm6X`}wxfX?Qc+{;zE1Du=$bo2)cl(+M|H7m49pjq9LjIA71Ig4(nZBK-NyNF&N1;@ zVhQlR$@3ej0qo25eTKVh6=BX+xAc!sr_No?Ki!nfHTroY0SYp16jX!qLGZ)2AiS`i zpI*n(NL2A3uz%)VqP$VIQhCPhw^mFlwLa^IYJrb5hHXtRLy3ObPVHy>k!(hdGk*K~ zzh-lMTi8cKcw)f0G^}@r;rtxHnfK%k3u>`++kBCL>Z}EbJH%QWik%@1`OJdj=T`#J_#D}eMSvz%MMr<^*WriXet^lX=7gg|3 zrBIftF#?KVZdHqU5{aaJpTHrb5(-WR=^8CLG69kI-o*tNUTO-+=%_^1()0rRF@>)H zKA!ZGCsCHhRfmCbpGl-L*<{JlltF!kyMq1CON#AqJVVSA3t8Tok!ggP`y9-$e5$~@ zlh^Z>A(r|?CxY!?VeH(38%7m25wk#hW!-T^?OC!v_hRMt9CZn`yOw8x#7>h<8zqKZ z<0%;PW%44TS?H;!-8)2O*Tft(SD;K>;(JV>zy&o_OSGo!vnG+%B*3}4a!)z;JYdQ+ zT5LFX`?Rg42Hj)b&}ZR#BW$%|*< zz%HeHUP@vI(Q|&zUv2&M z`HfE79pOc&dRd0{OUF&W=c_qVNN@{whX`9>rLfT?pNR(x; zXBSd@%x<}fiCG`G@jb!tUus%0uy1jn^|~o@A4%m~TXNnW$`IwF^8RRh==gkY4%rOz zDY;o7&-gbJrxD>DOuSckc(1}T2;Lx=(n*dLe#kE|>6Q42NEoCe!Qme1-z30Kz%3YaCg<{bMWx zP=AnXshI=Fq)@LsD?ZChRFMmE@G#9^c-r^5d$HOg(nsufo9$eKx*Vz5@;v#@lz_pF zeTv27c}Dj~CPg2&1eI@h(Rf4ISd=9TI|W(3i&BQ#xltq+KO!!nmyx5I^SN5eAKHH* zeb`$tS31wZw43wwD34&0b73AJD$!-gV~$d{dvrQf)FSeL1>t>0Me;FUsYIFC5L#b2 zBH!1&-m1+{F)!@5zMPN4HD=j6C@`kD3V^oq&oR^0URfy2(&vd8P!c1$Zq}FU|55Wk zyh(}sT5`8}u_jw$-X)KfQi0!BD6v>MN{6}FR8He`k4;9?gnblmM17sm#T+w`naf}E zaCB(3FCvR6y8pJ?>>;sy`f7T1LOnIl@6&D``y`9AR*=D2s*((|zkR_V0NL@Hq2YzuBNPLc)4#Xmcho_$n%)ArvJT3AN=M^c^uPY7cq z|A}hAD8=obgI%oUneX;jSVPagb`&jfpC&e6NE_F1ml(Hx%ws#TZB~V?|1z4vyB!t; zCw$%r*#B9%TvoMtavAr3=z8m@sJriNSP=!JQ9zm@q(uhl?oyC$MhR(=&S8`sq#LB9 z8>E}LrAv?;8tIZ6av0+IaDRXCtmj?tzbw|woU`-n>)Ly(vieh+6(_d0fOS$eO8Sgx zwAQ*4k2pKd7}!Dwias+XUZR`28+5z&F~<8PStOm)A57kckp&^H1Ye&?B{V5dVmhjY zbcPc=kxWjqR8|7%Y8aHQnh3fDsIRu%XDL z^ZGp1hV`S8H&K@9rH6uOdyIDUuS^MF(W?MipfeeF29`<>V%QswaZ*nzsrrt5pWa$? z6h)o(jDe(%{dTWRdAmVO8(Ouz^kE^vN@!y`m(=>W_*2}8LIQmHUSvboxKy;D5#*awO*X2E3)=NOVpwT zc_pcZMZLZY_E2k(Yg;>3d$KlZ!O-uD!wzd*I!zkYSJNP zef%D`DzwiKvv+T;vLYJyy|TFcq%2D=L2MUEB%E{V^!Z3iP7YUcB_unCSF=DHS0hbK zPQlQeN{b3i1b!;(u^;DMGGr*hJr`&pd+(#zk5201uek4cyaa@ulr``Dgo95)Gj}O8 z8!y7zKP&fm(}}Gv*)g0+i(?+*JX^1)6>)#<_kg(6s&8{#KalP$JXiA5qsuA1DbZ$n z-{^gPm#0?v`Y-grX2^zKe;9S2UfWf_br$Lf z47J{TqgBV(>NTNll36L`F~rXqShd=TWCip3)vdiEF9N6I%tpIPq(a*#+xNmsRb$Ed zjIBBnMO^AG3hHP#PfyoHrbeuYIjxL4WG3~SZ;y?>TKa5hxxYCpyfAK1T41(ivz!G! zPRhL8ogowJ&YR$CRnI0%5W<6c#BAy9nM)(eIi%p7~zd+WJo|zu)|D; zI;=|9*Jkj^sGhKCTmNcEf(d+#OMfg`nH2pfT}Sh$L8hSZ7wk;Y(xj0flLRhg=OijA z!`Eu2y7CsKj;3ME=-t&-dlQ)Fqhhy=$T#16H?nR{*hJiSYEQ+*jBl{ub2F4Bc?bIh zXa;_#lG>4HVk9ka&MauQk-w0T>eOPbU(-DZ(KG*AX`a>1%OZ-ptDSH1oL_SZ@kLGh5u+yYFY{;p*~rOgqm;+euPMCel2d zKI#&W=8_<$5m6+H*zENU<)Q9y;cgL7$Arhi_`TF(4E-iH=zqeuGQyF|p3an5o}77| ze;{UT=0@DHYANfHmMO2?%?cY!**@ZIpG)5MK+Hp$$NpzH-)CNm=_%KV!g`37bXRo} z;>;@QvZ>tS*QDDy4g0|*^uzpWMThqK!RU!LczegM$v7+jlAt(5PAwMG*_N#@?@w+tc~uA2R0%bU+j_Zptlz6JAVi|Rhgpl23Rb1JpU6ACd1W|v6wRG94c zN6s&T)R=?}q7Sl2xfvc2#;>MYC(=$iUY=bt)kO%N;8A}lcOqUxZT@_sck zNgrKQh7NG$Qc-PjSw>mx`y46UZU z+evXPwle>8S5o}p07Mp-FZ+r$s1g6a>_6ZBJ=pg~YvzZ0vhJDeMEl`@F=rdU7vp75V!zsg?&( zYX^O?5EX>~wRi}4>rGU zln%dAkmxJ;DcNM_3+J1IGP#VM9mm+a6A~NBQ_UsGao&DZPaqo=PEyB{ zm=@B<6EY>%{CURVb7$>yuz&8|*_spLy5603HcHL(gR!LTnB}f_bKq6oLyIS|E6TUm zBifx4UfXTVZ=gLs5vi~n!J%iy_pr|E>Qp%EE)F&gdRq2;Fh}9IUJ?zjfP!vx)zxy8 zTdHrB5f5_*9VF?;LIrbGGD3G!pr_8$(+qm5Yw>#4Tuf5G!o-#?ZJ!+$YMQ})kac0= zF`H+ZN!}paj6TzG#frwyVpZZ)ubmw>yJ5;Wh7h%~!KCJmA3?5Wzb$%e4@-KFBM^1; zL8!~uYHPgM`$(b9lC9MStVcy~NCM)|@t3$>=rBQiqU~Jy+?nuEYF(sE-R7Ei)_M7^ zD9yl9R4xySa@(UWU2bioEVw4|P;S<^@1^`FriZoH9`AllxpR&^aUmIvW0wo!8C#RR z7>0aI#V0#%H-{Di3FWEpN=ULwO(-O9?^oSJF3jEmHDXviHnk z@OSm5=db>le4?lEbke&f(A@j4wEUkJOADOWD4;jn(Giimd;fmawM@E)Z*dyg&>6<1 zUW!fybFL53Gka56`)`hmsYXlAs*^c2rtVM+;H{>z#go(hb3# zKw!=^2eZ5=B;0vP z^>l$N-t!tq#Y4M2E~9r$qt3`l?Sn;T-b4Y{C;>-FZUo(z`YqSr((Nzc28Btk-yTm^ zf!={&pb8$@8I%c)%Nb27UAzer_%D7H6m8GZtU@*t8YfFZ+Mq|x?YP{{75$-1gb_XG2n zzJub@AY}uLu+g52JROb~rE#RWY<)X~#uK7>c2OGbrAhHx<7KgkrQvk8-l(j%gS$cp zF(V<+{3H;J*Q6;s>B&J}>8lZg`m!`;5M`yozZP9t7@P1{c#r>LveG}FX&RWx&SW?v zQeMAHfDSJ*%^RJ}ifyMDO;panCnb=1q%sE`r=xN%lUDh|cVB_?lt=!s;ph4o46@q? z>EoXh@r(UNRh;3tYs0wjuxa}cc);t~7F9)v1h8dP=gkDy%K1QQagH0A2A-JDco^%i zDBt){pV?+P_Okh#17&d64PYgSX6c@&@y&3Xfd#+_FISd`+H%Y2F|6#IZ->89%D8nJ zBeamZr`e{wH1BHs?Gh{S8Zc;lbSdjW&lZIMOdyGGA7DB@^=RmWXsmAWA@nT9JWQCF z=(e)}BW49Ql$6)I3ZXF{|1gS}yiZj+KM2JbSaEHj_nVU#Q{nx5 zZ2O_bDM5y0g$>{l=!}?#Tk#N+I);ga9BBh=QDdgql`b3QYi%gF>dj<^~8NTe+WS9=z`^`2zeD+PanV#fQ*;;%f ztxBCajBby3aElAq5AZ+R_KzK+=N6$4KlxovK=bC_g+sF{7OVC8Z6Y2nP$*gbqbb#3 zRn|m3uv9;KyQUwfvj? ztfbp69DB|iK5Myf^ATDwUzKV>xgD3RAThx5*+TZm&Ioniq+vFf&cwm0mSm;xv#Riu zp<|}0TC(!HJz;y+dAju(fzM31q7tIjBi?G!tQZx3S9CiX&XZGRS`~(q)Gw$9-pFK0 zvoQFjXcsM8e0iT~2AD54td?goebd7O2vg1+-Q3QQW}3nzTus z=6?U%8!~J8wO9Skg9>0)#z6yQ<{I*r9rH0s?R{r%wb(kb5!6G`uG`b)Og+O$GEt{= zUlSu5HBD;7dE>0B*z}3E=s z9hGJSNg3QG$ZZcHq}@Zyn>2b~0laKk93ie(w6m)-bl}uhx*>Jl+b^{C>$G2$BA1ql z@HpRGT}S?u$;g0#__&yf^(3?fYzePaxTuJ9&~qVjA#^R@=`)viW@>%{4HEeRF-!cO zm%Nx7Z-6&^M3dBTw5IEgxx=4u93Q$KR&2*Cx^27G9g%!KrI%we zbNfnxZtI8?TDuH}XTmfHWeLgCW#K@b5QiRcyVqy91uf+{ZcpQ)zS3$rit_3x8kX?O zxL(;kauqYYu*NIDo0-FG=dILUN%l`Kr$+zLHxhw^ead8n=4i8l;^WQ!QT$2qR@m`& zww4Tn;gx~l`d{5Si+!_+>#H#&rwb*D(iMl~H_s|jD# z>3XRpmFuU8dPE)@as6KEIDV=GCAThvGW%VK8b12M$@$E2^7yf*U;=_p$#{)-+ee;7 zp%_;LJdgCm0G{CyyUqApKOLy zPF$=9jk}Zn^8w8LK;5qnLv#^fxL11TnmxWQ=C@~kue&EZOd`vW%_ZSeHSYm?&atuO zVWya(xBmScY~Iej!MTBvg?482LK$u@0d1QpYt}xndqWznM*9U*w^@KKLJ#4&bsc`w zUwS)QG;Y>Kv80_t&ZM9GUfrzE1k-$0CJtd7c>&kTxgd6BvYLym@1Irp>AmA$&)Z<7 zZ&2*esO6CG&nkC%~Ft24&Kuu98F5ub@QEnpzG;6B$4RhDW?~?4Tm~l0^LJzBvBvO{zHx-!hK?5@%P!U8{*S z&nCslr3RrqgF!KBrx--<)m8b(>np#TU`orS_G>NurFRo`-3x1#PKMvfYA^Y_D$PRf zg-k0vQdJx;{-|g`*Z-iiUbp((A3?pZv+$ z;py1(0m%*IqunB4FqZU_Qr!2CmxF>cUe>CIp`kgaEj2m z*2JWGxaFQQ$-1LdWmPWN^AT!K0tSSc&$#+ewHn^WciS>|c_(Ug3 zQvKX2zdU=6>G%$h1@`ee6BKM&T@hM4lwyypr~mw{U6ZVMOlTL(eG9~u_yCKQ3+ckf zkk7-PUV8F&aa!hI({|WU&VKc;;%UGk{hhLF8e>}X-&}y{Gx1SG)31k|;Ah8=cHO2$ z-aO=_tNj?S816OEYh4yv+jHcoZR`6OFzN^L_gU`yFP2}Z53?XuKQ2VaX`Z(E%t-p( znuMeHR~VDYU;$98Vu_o zFvYbLiVqiI9=q;QpVMvBbiUOb%ffQ96w!Ib_1_&ly;9wwULNr#uxTk0A!efaL;=e1 zGK){EiRP2N!kfR4^cj`Rhbz$KRPnlKHQUpjt9Fqjjt3qrT%Z8(M5hP{OmrO}*}J)- z7)!qSSck@$NCr<$)SG~Ro#+Eq_iFAT7<>Ha*?%?^4#{G@jZIW=>(skJ-t zEQL14iU)IUNa`YzD^ox>qPHhUmBTn1>R%NdG#YQh>*A`sb5iZ! zO!3$JlT{T~hM8*9yt7kI#&OLDZ$ku^y=&1vVW)=ViAzk-29}adtm+qC6bss$!LFki z;=zw`|6EX`FKt3vn^%D8Aa)6oX-}-sXskMVL}19in(k(4ui$L7FZsyXh{uxV2u^~S zj~SM@*eqwf3g+LGJlTzXkr5Um5BeXY^=Dg{y#tG~^eB%h&;EX{vN#y#gY|5eM`2HwJnROtl zuj=D08JyJgco%W@R5i!2cuz?)f}0I)F(N{V>_N}OpPFWmdCIac2j32Tr!8#^gd3B^ zRR;Z#oEnSq+pcF(#Jkse5<0|gbD` zuLA2OwzWN1SAlTnmJ3^-kXsh)d-8Bqy;&+(QT1wVT}e9iI{PklQ!i{3puIC8@a5|B zKfM<;-Y?%o&6m^;(3)t|Qo3vfM&gx3GrIco^SsXQ3waiB&!t|%Qc{b1mG<}Mr3vlw zmcg0(y`a&Uwqn%shCHheiRPArFE?|BP&@pyJKGZ;@D`*Xv~&dHlmyHQl#|ZhE2@k> zWkC*@W?!AsGIBR8vTH)*KcC2_<~m36MOTHv7rK9XgZp{4Cjm|Dsv(}6Nfz^o8WBq@ zohAD=nU~pi(LvZV1`O}y+9puBLYt}8if5*J>8(%&*XIyG4u2kBc3U-+LC#b-TPm^n zECu(QF31LxKfF~6-+GVHo~$8+2Jl|~8Km@@Vl+2cLWr_3^ea_~9D^pM3Ld^}%90Mx^5t8*s#YOpj8PzzdU*A!oz9S2; zS)aOfQLnKu#a9tz-}jC&yl%UKHYr5pEWrIc!9S7_aB(>!ojw!!Oc}-<_o#o`iI)Hc zu(lQ!<)vMXc4eLvPaxqIH77L3I@KPa?`zpznQV6^WR#Ku%1D>8Y7)4n@_H6j$F@7G zBIbXW-L|VhW_x1$%ic0rbBc@iC%)izfTKeFLs+2pZ_@4XX9=nPI$+kuaCW}EO9$qo zTo~Nn{#T2bNI(@JAI4b5h`0MTz9yc1>&3JMT{?|Jt@!1S_3xb zB_J{%Fj+2n3!gVeWqQ7P8)$#1txt;Uf?-?AN z0{l6CM+8bbCz)_Cd3J>3;ln4m=G;;U;n_e|Ah}SEDGT>OYSNIi_ znjN-4;}na~c(7h+A*y{byF!RMw*?elogF3?vMVAq8NU7I$Tu>1Du`sH^M>A&)l}w& z4CQ*~gh*5bK3RYDc^_rNDQ^ud=nyxT7$dtyXWx^i!-)8iy5|QUCJsGfJvEoR=6&-pRGZ)TmF;(=WEz=BREx80^6xCFlQ5gD>OpAun34YSu*c&4l z2zTb*NwV7^cc_iqSu6I|gS?5U|I5|~AOjE}SSF*8fS=00Iu!&2_XsEswc=xZ=M#a~ zD9Y>ZFMZ0uf@I~u&!0);M3_oRpdpl}aQaR)4`qJ%gSov}AHzaBMPRL;dzD6?p*&pH z?HyHd7->~-ZEI2Z#CQ0K>?AjUR`DUVL)n#)#hABT}!>9iv`-UD)7WD=|zC4aIdmALjwhu+hv=g zn0k_(b!fS3vmwRZQa^jpu}kD2Hhfl;p%Tj9CsYtr+u>5TSEt7ku}ZOr$(s7 zcu+$=I-j(@W^byzd^YkZVOdRC^vOMEo-Np&aL0bWz0ta92HZ#jV*l|v?|Nl}3=q`; z$*!1AFRfPO0rMB@g9676x|EMp2wzUkX!#*t`yD(|?GJo>+VsaPi~xAS`Ctz0g*-%yQCAT8tSls2#E3{S}v9fR%ft^5cNZHzfEqc)hEJMF z@=^H!?@Q@8iT&G=`qzbQAy2yo-vKDqQ$?yV_T6g>SPYRt4k$rv9}4#;M=T z$u*k8x}+I(YpxU!_WVnE{eAHF^Nf8%q^AcrW^Xi_gdaX_AD-gj#_juwU~sy+tf73< z#`lD@-R&Khr^C4U?h%~#Ro7F49>z72{XMoey?xyE%FP&~ql|Rb65Y|$`t`F_Y76r9 zXT6QR4!uBOnY9O;6Xb}9S>6%>Rz!jP`5-MoE|zTjsj}3OUh!~e&)M&qpu7DOWLelN zYDO~LSyGs2-`Z4=l~IjI(J06NizM*#VTv1A;&XfXJUiJLMTNVfK4v*Yvmx&FBVsE? z>@c3UH*rM&YtHU~!{LCn5dsx{&?_OMwv@$hpZ@W(eS>=>e#bW%BSoDXIp-1JWqy~h zxEA$|vl|0YthfC(eU7@4M>~FD>}``JWi=w1-g@oLFY9z?0^sgsai00QsmuV3#b$dt zqlk|GQ&uTG+6LaHy9n02(H6G5?K{?Htz{|Eor#Z`OyPZ?5h*yZ_ho3`d)_&1wIt4J zB6wTT`%dfvpCjblD1ky;)P>8##(KD0;P)R8C3qo_gZLArY*M=ZolS1R>U%H0VrQ$? zN<07oAg4UJJ1_O0V=a*1>96?-*b0Mu2}`1X@&$FUO?kk)>x zyZUASLWeZ1bL5TQ3|{R&zic^mdg)-^^%vIZnpUZi-ql>_n7^u$WjWH0=Yc-;BaHwc zo_}aoY;-n)n{<_A&MHS-_)rDF{0;vF;17yUr+Fpi7N?Oh(sEWRcBe-nSN@azDscs5qFDwyT4E z_;X@)%H^-;e*yXe;OWt$jMK@PRxYrZL%ze;CAMn~|NH?Gs#cz(?>n9G9BX>m#d}gmH(>GOtsK@5r9_yOD>R3yZH(b0)QguggYK@q$Y&O zYgHNM4(z40J9=Zku!ZtMU!rJtt^X8Nn%rM^Lf#`a@_HZcmL)nnq{}G4xe-yv%hnYS zKn7Bwe-eyNt!OYV`k$Zfrcf@nr+X3q3jwNx%A(cKyA}WIW)>ga;liH~{a)|yG%aSa zvGA5;mEM!QA_+lKJD4NHmFg*Z+idx2t;j__p2_%r&}wO@l$I4qcTD^N4uRfaJ%$SE z9P;&MA`1sVOFegMCQ#FA{JN?(xC6<=r?ID1EqDBdBQ>e=DQ3}gRn4HdFlazXF}Uw7 zd?{#0hsycmS9e6z#ZJeonG9f6nW95rb=OV{SqxR#80oH$@&k!imN^dah4Lv@WI@Ah zG!IG5PjCGRkrSZm)IZXi#8fAhAd_IvvA1;*b@@2pByd%3O;IJU?CVUyCGNU08Bt$P zV;d(Hr3-m+hP#-9^OQd=!=7y3ahejQ)MMotyo<+%Lk~Ho7clognR|c&H_x!!! z^u2ZWJk>e6<+1)CkHEe0WFiYEt&IiFZxk!AxhvE?pWR7~>69@k$B zxq14!2~>)n}jx*{%nzp8>!G=T`~<*2$UD#KfK%o>Kx5cWUCNXpXny)a2m0pT^?VH~TJTT0C#pUka3lrXtOMT6&rzK^M|-2dk; zJA1JbOlp&(x+LIHZ{8v|Jxp?(_gXXZ3v1S;HWaDMLmP39d5!%!ERzJEA%}svVQUp` z#`M-Fc+SMnGdQ#@#&4S4ANHhYaR9UZ9Q))}W+DjFI2f?qOfJVN2-cl24}M}5zk}>o zqz^Y0G2OZunR?!{{UE278|k7yZrJNc3@`-?rmWaSFcr6q`E+KfM?TnW6Svr zB8jzo=6G#HCxWue1+ewC!UgPnhiviDICumq&y2|OH@+); zwZ#Z>e>JH*!#50LH^6OfJxEp?*aN+5XWq&WQSiP&?#HuBEOpxX~T8q+A_ve zz_r%YAmV~_b-8D`OMFtiNwKmtIpo!pSTuV(bixzghG$5(jPsy9b)5qLh{*V@HiIOD z)?Ud2_^m39#RIZu$5a*==j0Fly=?7T9N9;#_uxKCP%GH{SpX`TMD{g13=g!A1w6ef z;}L}cBOFaB`Ud83r7^TgJAFlkhR=tjJ30MIMy(;oI|!@f<^zj=CQUT2yYuwa9eZp% zv>M3TP@;j#&IfAVS3rgLXZN`8K7Ng8miNiH?1%~Ns-g0+${`RJm}*?iyLM(nhi~z> z7B%pUcjUC$99+-T05L@s25dbXS%>gXwJ^u<+EhZZne&LdVjK;Pg%e$WP9x(3p0+3x z+e0dTn&ihw`0VR_hRf2Cq8qDwkF~E_rR0o>qALCtD@x@;SR7tO z&=2>Sex#XI6zv?~KJx}$&J=JkWzC5PKN-0Qv(dDM_<#N(e^L_lt-JlGOqRxfM~$9} zu<74S#O^&Ujbrybf}?I*m3`Npy;CGxqIn2l4b?t`==|XAtv9O2QtAcNJ$lM;pWHY* zQgFqD)U8p(W|5q~gF9tjy;sk3UTDS&?-c42yZ?aDTUne&-ZlDh z>IW02vGzP&%l^_(O#gPe+8y8e5WFOH9P#ZyD|xwFRGwihYK32`m}!>i_@(TpEguqY z<;h~^`FnZyHfAPxmq7e6Ay1C^c0|1lqj4qvsv&;&@}2nLVjDNTBd-6Mp4|+MI>Y%p zXYEVSMl#gp*u<9Y!&B^kqLKWHdAZ^E3M9Ew6YA({krd+0=4AhTWa#$OkcIL5V_!c&Ova+ zxg#5xiRr!yqwJXk>>v*C%-}oMZw{m!xXzS7zU!57r6A9-w$fdi9pc53F#?ba*MVTb zUtz5O$EU<E13*zWft(^ z%5=A-Pn|)E5Q%yH5257=gjFrNGlwz#QzF!xA?0!3%Sh~@#^#)4YvcT@6V4z%%?%sa z*`Az{Hts9=gymMuBSL+165H3YT2G9_&kqR_t;T3PPU@`4&plvds@4BTv^)Q(I_pdhk?$n*j!1Y za+VmQmyU0B@;_z($T*%!Uc7?DiPWW?Oqb~PzEB@^F10PQBR_F33Zc9IrcdDDR$@KER$XVEZ-Vl9hz%d(X3k$ zUe%39AE=S#TqLF`-_6P#M~(%snT}pxl@1r#Q@fqFI=87{TqHINcI@+d>R`5x_$<`& z^huxr#%o3qpmDl>|4dy3VC>=5(Wyw5IC!5>oO-LQJz@>k3_&wg@dPn2X=pw|hh$OX zDz!zh>kVz%v@A+78~l4-dyuN~iuPo`B7XEIwB?K;ZZ8P(+1cq&A( zZLG_mOIps(h!Q1dJRoPn)KbE1>BIw31zB1-RC@u^KhyJ-55Df^pWpxKFy~Zck@an= zodEgN6=wcI-yz!H-OXeU>P2>T-pB<=Xzd87B*?HJ{KvjCE_9E;F6WiMN08q}y!{E` zwuuM8*oT$TMsx6080vqo$~VkhK$?E&c_G9CNJ_8p;4QD(IG1b0omJKkKyD-Wr@Y_B z20XKM1-$_6y%k&@FcEO#wydQ1JeVWMQT(_mthQZQQq%F&b2;zo*M_tX+c;TIJ+8#Ib} zrPu!VF0nN$fttnWxz9qxZ>x|i1(q^(yeNzJQKs@+E9sw1PB?P1tLUMPhZ{z91R(g) zyB1zw+DL{7O1fYok#_#=n6Fpel-QpnKJoBXoJcaR@==^xD?875o6;qM;=F%vJ9EAf zsGwvDrK3Z7Fk}W@OYExxDTB8-fFo@Jkd`&&otS2$B}lDy46PtH+GTAzEQm~1z>V5U z)m}yNG+USL+5lVupdIB4YQ_FQ*+;Je#Gtb2d^6yl7$?TpWUr_nux?$w4zX73yIDIR z?3WXbRpK2eGXzL7rhv8T@>7**=jnU_;B)A+$OxN6f{r7|A! zj4amcc^2dwV;ffc%L;y5*eoZEbQurt?iH(wjPN!C(Z-Tdxe&>cgUQGUIYL2WG3`_? zPf(ve9U@i9WIGfSdrP;}{^DRd>tjBV3@NW(p|T}8nV$A`Re`ubr0aibCN_z!TlzJQP<8{$j!yAm`Q1)8}a`VnFZo zyBq|jq&T*e;1KR}C_9X_Saf-S*8QWA;OeFHs}nIkt+PVmq!nQZu45ijv6e5#H1>=d zNpLL!aAV062}i@B%#+|TC?@Yw(H_V)Sjq#~Jhke?^+=l=pWEQ%MDl%LQgte>LT!xR02s0BYm2PL4VwoQyu*W< zR6Q(Owz;&Mp}Zhr(F&-q#KZro(6-9lQ~+EBLgYg0 z!kt3RvJ(2>l6Ijf_g4vsz1NPWZLKIhVnd)k2gInd$>%WPh4$;RS@m&eeauM%^v^8B zR9-#4lQGWH1j9Pm>>6su4CIV;uPlHI8D*`j4nZH+esA$<3PPF-}<-Mxr^5o|0C@z~Emq=$m!= zh39ly3_{s8S(oS)?FuFe05MA-d6-^S(Yx;39pRH$J)Q|I(lrfXU+Y!4#=;%{J!TWe z9_~nP_}2y&H5;m|J$Et;r|Z7O9EP-|MiqzV!goKPfqZ5Jo2fNBoOS!BMxq8jwJ+!MmCq76MB5wha{##w zXc^rQiJ8~^w}1|a=VQAW)9uT!?IEGl|K5?BmP&L+8pW)L zBiw^XP_O zKh3!8W`cZ`dmoTSLmnk-b4J)tPHwgFnfVKeX?d{uS)V-F_Ik8GqG!R+ftYI4GmWJ8 z&+4DMpVbGjmgLyUMwUCrJM-s$W@^ppIGI?C-OO{tb$JWsxPI|$IJ(yn1h6P}6>&XW z=raiW{F0_=m zoZD0UllX^px$m_vIg)HVG%hE5^B0#hY_HS{G zRSh8=Qq#;oNH;rYG&2buJC(vmNs-TKWMjP^E%k8g@v3MPn7*vwb*4k&=NKtC+|ZJ! zgiW-bt?%LG2%n1AR$y(HI_4VV9bubEjcHtJ0X1?#0RALY{c(kGZuxP%*})8)4T8>7 zIj?h8L~A%p)M!dXzbKge&*4%?Q+QyePaP9H9|02}m{!6KVEkq3GuA|G0KqLbh7@q}D}Dy+x0!RX{|Qq)SEO|h*FUxlXrdY9v% z30GzLn>ae>^GJW@3Trp%*ee&il-348y>CYQG{~aTYPK7=Pk)Gr#dXQ>GZ$dF@|QXg zSkxgT?i{~!iVB(7m{frI)q@XUv74j63X=&$MS2>0O&XSu3D5WhVJ55cEYE zQ}d$Q5EwmOcJt#eLO}CtX}s^$+g7JxsFZ_F&f@cesTYfT@7 ztb|hNLk;l0vp!HU>stlz>NLaajBm%DPV!AvQ6#dNApmUDxAvJEP*rxj3r&BtV-Wz= z+LSQ|#S~`uUV2fr-&SZYQUU6kGEhRDTJtW9EVdGH{H1KJ)>J*zBq5>pwVY90A)6pb zAu5X?DR@w?xZQvIbidktlYZ4FMrlo7aDdWRYeLH9R+39AgswkXgtF91UwqTVQDbV+ zA+Eo0Fn=VKrL~$iV&Hd$h-$g--4`(Dy&L^ySsMSEhPX>p%aOTJU@q6_g|dQ2+J?}-^$s;0?vI-<4@D-)u_hB z8&bQjM5&sj6mG1HQZ6m*k8&&fL0=&ZedUL_)afIvg?~`mClME+1OA1Gt~`nS4Dp`LH51C#ssb;-W9@p+IJE^$fz`VDmT#)I`gfio8I z9iXD3SLc;EimXd?0asgfq*~>p_>c`ry_*>X^3`646a=e%IQ6{q(6;#PqvSi@Yfp6F zm+ju2`Tm%J$MH4?Y~CVOj93cuFzVF~De!NEfO`)zU@tFy3sWKz7nt>O29Own62$I> z&gFl;HxA)r)(T{Zcb|&pa7!=+LRwEV8|$kUAf)M~TL@wSKjo;W!~i|FV#D##EsM8K z^M>p}R@drIR+yAT#O35Df)q${nt`Lz1HKg(6n*h`Likk3Qc*7I2=$F*mO2-#`We5(B^gxJ#eextp&a) z5J_}e^BD502D2DDy7}RmJ02)V{NGY2{c`*>Mqb)0>HUcU8s18vEc(XIQ8Bd84{$$s znMgbW38q=21R{>Da{HZ&Pj@c7Y8U6{)smcvbtv;S`bb${G%*5XD0hk0N<`Vt!FqRo z!`g!T5hwGP>&xLFRC4W#{A_S&M?>A!^=fApht+nEAaG3XyEl}wJ!AAsr=sgYAfRGa z;_dpe-6e#^8VgPDt~|PTZjIN#w|MLQiCN;^cmM6LyuG6smTE~hoYS_2nsY9IeE=tr z$=L0>#1n=(;AduO`rBUBUIVvsgRghUENEnLK|qr&9-ziIGP(a= zY9@f14FCwk7&Gx+ue?z~45-zBoU@439_7ytBWW?d+ zR2_~5asD9h^Uwi+Jaebt(_k)krRxkg&f*?}O(NiAT>7p|+&P{jX`ExoE~a4D68uO< z;L`8T3}+^}Hb#H%@%r)x*IBAy(IDq$)0niXyD?ep4zHq*ZWvfP88}$eIA&V+tYKn# z*$&+}U|%O;wpBvM#&+3C>F3iDMhZ zclA|^Km~zSk0PYJrf(_h&nK;zDjrY}$sHo*tT=v6Q2=}1^-CnqL-rbRe!1*_=St># z>F)n~@5bxAaISVXr?RiQy`AZ4=+k`xCwfrcabvn!<(T-bi)xW7xf7zjtx5Yv+UMiz zwyURL5JYTgJTG(C3x33uMgmmhfwJb!x$n&%9G4dM{zjM>z={Lz zM`#f8_V;1#kY9@IQB$yH^|C5oK0e4azH$@x>vI&` z3JYoJrE|p$?Hok<1jSUyyp{=%IC~Qh%OvB3rMPMjFO~D}G}0s>x;UcN09z;7)L{^3 zZ-U*_XaXU7?aN>IsV>Zz2teM}1SqL_YwxTRHs=^-{`piT^ecPP?JTmiXys;lyHwE4}+rtLhE)5YyYJ}%rB&Bgb$s9 zj(@n{dVIkwN(vx7KCO%yJ3GY%EvkHSDJPgs%*nhDOL@Xk%KKE+BhuQBFA|k33|uIX zZAEwmn8R+k# zZc0V|<&%Yzn7b7I{Q{UxLT3Y~m7R2bYr~7hOYuv<5zctzPE7YK0LH5RZ+Q~XfW0@e zDkZH4LI&3vBB(2!e!C$dvyV??O*Ga$>&6bh&onBD#YYD!4gk$eipF>#iotDB+X z7q9ji^ncHw^aGWp`xdP>A6xz&e(L?fEbla!Tl$q5FwJAkLN1^c5lgZ%EPZ&>zfb?@ zpe!=J|GuHi%j%9j=IfFCss57VVARaM7$n*;L1M<~^K8A74$K zzw~l-FMBPX#L?2Bsw+r_vHpC=ut>kFpaW_nYa(Onn#+y1RCF^H!QRZ8xHS2Uw-FDt zr{w0{3Xl)D03bMSlem?)K~+qst%e_n>j^69H0dOT7uMLNOBuS6bv@UskLML`L>~mO zv(%|85LO^e^2}U@#S(!My~WGu{ox;4c&bIQ_J)z1m&lvNGx?9?_3Rve>;+naW*i&G za1!Esv6wkIHQf?4@D7Q4>$23?AVKwiIQt5ysJm`&0|Y@Oq#F^DmhM5iMY=)h5RlGc zlop0AY3c6HkuK?ykU_czqqr|!YNp#xpihU;g*B38&sLY=0NpLn#w2E`-_qd7X;sq+^g8CJVU6EsJP78QqXq)r zOM@5l(_iargs2en3*k^KNBfz4+v$sNn9j$h@`8HNOM`Ls5=|#ChKBC*Zx!`W(&avD z%g0$Nj1EJsiU+JZzT%#?9Xsos#TNWBlxNGDB8)k9W;(R2mCmU{vrni8q;fNDbwNSR zq!Z`SEwb^%8~i@JAM+iA%^w%rOD(+c@+We^fpC`%u=oIHf=vMbu7)!Iz%Q~EeTW^?R$bzdK8&f6pk{vIYt6=cs5cC-`*dQ>Qp}<>z^f<|U|57sFZx z@{2xC)Rv{sXu&bL_2;Uo6hlALH z?6?hZO~CS6)tRSKtieG>SBTnn{2c+)7_%{g~p=k z6~h4$jXFjKE#0lH97aCnq{>PSoxZOXWBMuu{o8a|#h12<4JI=u@72q*Y$?YamACAr z<-yL-n&SO8g-rI%URp^5EGoj`{kqoM*(dGjReYjS$WU7D4)k<%G6Er7WU07`V~BdO0mEcagzV~6iE4vQ0)Aaw zGOxlU@>;dVCP7#F*MU^1dbWMn7LTg1V>S~rsnDCGvGE-DiI-NvHQD;b0#8{8nYHAO zGdfgj-+dmprBrD({W5U|j7H?ids9@|4x*NyIoed^wTV~Xo!_i4UQHv2pek8m@87of z7c5<0{QB3%@2mwHI(Y@rwqkB>`NwtVyK#>OJnRN9GyScU!oV@=TPr22byo$J6Z1l0 zweeWKK7KI0?3o9)=uS~4L~Qia-9o#Wi2_w>yF~j++J%E9;09^*Js5kOkgN8ojMw2K6IBx>mqqxMM934Mz|AF_0{UMwSl6``>3` z^)yikb%58SLK2i_4FiGhty><8`;;x^Y(Gbwxl{pMjGs}6}8nw0* zJvA3jnw4$6U;dt{hO_@IZ0&2hR6UVST2^>%4aPC{f=5pho36bc_s4H4)2)weKXrCH z{>o8MZSe8y@T{Fk6JZ7d6RypB1kIPFvFrxclxir!6siHRkfi|1H^yd`r?frgxZTrf7CzMxsiM2c`ue`I?DBUjaAZSY8! zev{ISfU2-*Fq6atdu1`h9*08U zXXj-b@nc*oLxh)XKQViJrkG#xvwFu%*DMgq{yZU=h<$n91Qcc@eDKCJ1QH-hE$RCT z6^akXRsK_UC7t97LK@L!&x;3=9S?P-IZ5B6ik^Npcr}TaiQNQ^$k{)AvQ5 zmo@Z8zVmmM3Jg+==X(N~&tObP#lR?%{!7;Z0bmGL47$UX`m>_oK0wOI+DOAFRum!+ z+)~8zoP^dOY$L?|*lz80Cd{F%p6q|hggEBDVSlc&*1dY(=bfl@!rz(KCd;)S8$&em zXTPaLAV7+jjao0je$u@%pN-^A6sjE3|9P1ttkCCWdVGvjf)jr)Go(ZMEbdKwjT&MEU_4(VXNDn_3&PX;H@VWWe+Gr>PC!o9ktqbiy%Vgn$2xZ?Al z2WEb6-Ha(KN5nL_=mgTxb^9g@@3|8N?BAc>ket;_E(wn+=1xG<#O_auSV;zjJ6pn>{~&05y7eBy$>JGtI+1xg7(Uv7g6K4YFETW@8)66e_u_wAnu zpAV5|FVN+I@RMT*xVzwg7$raeefrl1vrtU{OBDpuaRULx+txl4@7tbg%<8jFVmioN zq?6Deife`5q;f^8$D2c~-2TI1;)*v@->$qMEoTsr9h;+|ZCH)=ON8BPDWW&`E7;%p z<(wV0IsiZpDScs<+wXM)8s+~(@~;2Zb6lDKsqlc#o!;U+!2eMEN5lfKS7tCOOSQox zG_L*b{p`h5H{Cdm-C45_D1`z5DWZS)Ffc*$Y1#_%d{|V@$>Gaw1}u)bDfmyHtkPhc zydrX%vI07U(s~mPi!kKCeQf^M#ksZANtCeoS=O7fiP9T()uszk09pdl-^8S_n}mrE*BAve*Y>JaH#!BNi+FXz zbau1E_iJ!kst5nAv#G#{FGi1HkPX)2dRojP|vB*5?Rw) z{Ob=yz9R}IZ}Odd%(*a+JN;5pmklQ&o_zV%5zKZUSB!c8cCvbcludfm%p8U+lkGsl zMe#efZ*U3@_818(FrYAHVc_P4zw?GpAuA>pYgTZZ1fD)MnfV06En5vDhGJpC^#xC^ z-nMv`%pE}##y1xnZ>Gf0Gd8MwuOHod#_16fcDUJ&mT&!US-#Lm3m5R5gNu8N1;wwB z<_8bL-Cvhb1{rCq5Zpi}3S z(U03e$N7$EY)V`%7q}R&EpD2a3<9eM&Xe4RJ}7A#i;dcUxpew|!ru0eP8Ja80&(7E zl5_PHYm=9lHQ%+UHFDvS;}DuqcKbZ3T{x>+*^K#3_}?{p7UIUXbeHW(QF`!K!i~9a zCodgQD~%*_-m@$In*<5rF)-0W^^lsP8?A!5W9IYLoy`6AxZ6;ZvYuK*&wBc5Pqpfr zST%`!dvTBK^wYmBw*|z42Xz;J@JvMh+FPS@>{UrUua?v(_XX^kC}$TJ>h<}Qy@RV9 z*F#8L((#Ryyn-VXW;_3H%;8`?eymDO#1==+E5F|xrTVk3jG*~ES0me#KoD`*F)^Gb ziL@z`d!G(c75?y5y;z^#MXO9+L8-){C3yQ~Nm=Y7bfA*vL+T@th~dKNjlLmhLgxCh z9A?Fzt>3K&pKowU9nF1Nu;DDkRraz{5@8O2>;^ZD;vLkna4A}A-ms5-+@U|;H*DN@ z{QJSrTc1l>Pv2M+ESxeh7QpPU!p3I+rMpc%FlkGy>M5Dc4%g%su-Rpi1MCW$-^5g} z5p}9{reC;Ajo4W)Pvi#L{HUZlLI_ox-hEctJ=uY?hb8mMU00f^a)BFTACo>qw{OnK z{7>^LMY0Vy zLVs2Ad$jxrHh8g2XFl*flH*`DsR@uNej{@|BayX*i&My$^UDYD5nAArO(+TIxW z6vJ$r)dA}X{K;aM!T#-x0u#I9tDB)s)Bl!WY}P?mRY7p$3h1&p_AwlXATNFIsrWpu)&RW!&`1H1bfeVDj>&15`&XoYZ_q+CK56nsP9A%Y1hVb? zUy(nqc<=oAOpjj-B+px|o| zCIt&9r{{5^6sCvc2?1ps-}OaN^+>~HKsOjLu&G}ZR_&EqCWz?#n*d%M%Ue#zGQgDo3&%Hyy5A=4_`Nm-m4tG&9vrY zsL7YqFV+he*#}{6f_VQjGAo~Bp`=-Bhu6p*9f?=?r)xn)S~>Mv?2H%nuxcQ5n~twe zjc#=GINZ3i32}|3EyJW0#eo%$AGCd`XORv2uU-J!vF$V50=q)4T~R>WS@anp%nI!$ZS zFw;x3a8~S;RFqWe^xh~)EZ8b7E!-&F<=nqW^w!yHIU?eeqxr1ZT=#`xf8pU?iyQtu z+93Z(F&bzy8s=SbnuiRpd%YqIp5D031UU`2YCUw z!x=P~;$9=>2X$NMaR?-N;mM8u<+7FEgoWy6e_4V15cP(O6;?}sgazK!)f-&ww?xsn z-)h|Q-*pZoX1e`J7`di)YeGJjM z%@nV(o65`u6-#s!W#~SQ;n@IO<$P_y`>K&Y(X6~7)h*+LEg#+eI&TGP&v;KoW|OyG zdGF=6p8K7+tSYgd2oEOo*PV)d0ef6;0v`LE*@I~Ca#J1tZK-y#Mz%It2zJF^s0S9fIgk+cqJD>BZPQny}e5%t&KLA=*T%2Al5PqStX3(Y|YrE4o(_3%U`_YCJ z9nE8O;zo=f`{u`3HONY|ht`dDP(cf<&{YLdW~WYF=8vah)4AfX5WjzTZL-V3zC|&? zu)BKD>tFiVsIOw0aJssjw6Ze-YZ101f*T%RXM1@c?y!uq&- zgtV#a23&3X@@id`f4q|mHwm`?!R}-Hrl0p{h5hd0uh-^+{fiz1*B5*0+z6ur%WnJp z-79H513=Q-%<>;@iJM{ENL{)qd(i@ex`3%isMk{&XUn6gz-P4Vlpo^0_}c6X(tf6b z?4z$Lrk zgpAh{>MX=%v*q}ZU$yl(o0ugr@6JzPE)7+N0Y=2=U3MeEEn-DtWBkosKbcvfc|0rT zb3KBlkp4Pk+=}rH`QBbe@eRYJ&2f`cyz*Ku z6$7u$&h@;K6Fvowu;?99)=j@%WA}f)JG>Z(GhGp{_DvL1BEF8wi0s)Yo+XYWaJNn+ zfjH5A(p#KD;aAZSQ7!td#|)srZ=C|+4yg%~KI25Y7@QiZ5|+jkxP85#Zq@lV84nV1wsMxe^Nj2O&QHo56dr z9z>n*-2F)DIaaCMY7$TE_3t2cEwv&Mn>GQrP^tqM2A?TnQZkMPvt&4$oP47$s5K*G z)*5m6a>H~1ESuLp42-i6(y2y(+@WuzBvqW-&E%V-Z;~dCxm574^g-R*awfO z5l!NiG}w8=lyU^u8KK=K8Vk=^UV-@NJsA**IA>33(?bZ2*9PqsvZc)EA^65$YE@VS zw_Ne;Hy$yuliCg*bybeCD8p0q=3cw*ghJoVd4P!sAKlo1x+^=q!87YA8G4Odn?td#e7a>2vbQ4 zjkD>li1!a8^`EuFF}w)DUeY%DoK@Y1lWf3#&rHEG8x@{b16)Kq+2iroHV9Oz*U-0U z%k6(H{_K#LGlq-Z?NPbef+6Tf;`c&|PD5}rYf;>G&bh-HW4Mt>*!w6sm&9(L#yg2^ z)_aEUZ13xI$Y&Z;^l}IMRO5`Ra?ZPEW>+fNYGzK6yEKpZwa)kE5B|s$CssUcyXlZ4 zzSg`g45|fBl+NYq#!>lV!lDuOLz{xmi}AG(|FIY7_V6vFAY$rRL+=kNgz z>H8hn-Y^gvXn(t&%L9f}GV@EJhDQ1>mc|AIs+{aWl*^1wfGPF$Y|5=y(IKb1lWBE} zDd!2AYJ1~ZJYw{i;&b~o5Ybu3^G_!p1Zm?XP?p)s%U8DZ4xglSbfj`LrE&G6V#zmC z8p5HAPQ=SK+XyMWUiekYqd6ZKsr_k>E!NMXc=}(-PQgEk-F)-ko!typ7LPgI!v+N# zvgCw{s7F;`{XRb!^QX>q_Vz;6|W&3&w@sG@}(=fbBZ%$ee-k5 zVCZU?gHe7cKiZ3}XECIwr7LSyv01feyKNLQ=4_G-oQbqT6^b13oSKO(k+YWfXS!Hg zi|k1iNDiY1m|>ai4z)SugUglePTuF=i0XV>QaqFwenSSGz8lX)gKZupPEWObrq$cm zk1`8maWHI5JjI~;PP**97ju(nC>*@vuGEXqWN==C5J|icwH*LWXRG}_gVot+-EGi& zb#PNLu+&BT_*KwV>zixh1!fY5A9S<+FT0zWXxUMEL^O#^S1lM$n1w-R@1tfwqK2T- zVD8HApHQ-3l^neNXnSyRlH==fSiR25p9kqhBXfA)_#zKbEujnlh>U{uc*}GdxAmPa zej=0K>zM_Gy77OA1sSvpDM%59tzzoBh8YGBcy+*4muhe%tnA=fwdhw~S#a+1VIjAn z9Vuy+HYmZwh17naxeprP+zBeu?myFbk3XO|RP8lI}3 zxaM=?%TRhq7_a)xH^G)R5pTWrqIvCBNEL}2ngt#E+0)_i(9092h{oZ)lQ4d09V)RsOUgJsmtPU2A0Xt4cO9P2*hax6Gp%)hwOmCf<`rP^MWx6MKw(?4EoV zCN<&ty#9H8=$TfRjlI(p7q<7n0X*^wcV!I;oZAjx1begYu`N)_zFP)ssORhpb*-{G zy+o1pL5)Sw+nF@jIP!X&3Yd?Y0?bSWrm23^!V(dFS!baP%yKSO`rR89dpY2a@W38A zAF{_)3Ngy>V-&-k4bMYo(zKjR^ zHpYx{_4Zy2Zxn1Atc`4Ct6{}sX{IjU;f!~z?M7t*VwNIX#xGRPPi_=0PnEq;Q%wI3 zjtu(J1!4{`9*?bLEY8L%rphZ{o=&6GGNRdQEG1SWDFp~+5hT=n5uRvIra=+AvMx%j z2m$Yu+P%YUhK6(0PKwplHO4t^)T+$~sN&nEw)aATooJoRuGrf$n}5a%^JOt)!Lbd) z21Lns#B+jy{afYZ8{qch|FIEDu6Qh&h^gC+3?|D6z`=PU_H6=Zb&Ju-^S~kE zK??S4jyUmfmJz38AGttW7Ub8fH@(12O>MleaNhVTiV)lY#t)>{1zfR)z+bQGA#o59 zIjBztf`*~P?d>xKI}bvhS=i?VKGYyvfF*$Cnva|3FvsBW~Td8Fg|+=>uIz$gYU%DydU7oZNJy6ZT9?XBVk>m3I)b{ za7zdaYHfhoE{3KEi}Pe7^>5eY8(?6b?#KSFpodo&Fd5+Rg3T>i65j)j0kG63@i2o% zOTcd_+Jak5kyzqFGzX^wH&O2ncO?i2JT-wQ1typrJwiU~?C24gt*OmrU9lexI9G4D z*{c?fM`yj(>hk%vFMELc> z*JB;&QZ?-tl<3U}XL-av$~>XQ{`M&nlXYPVP*+xvXav*gwbs9pGSn-L_dNOZ^(EiP zr8JNt#ZELkBmJo3A+?52QQmq8+6y20(hFasJ*Zn{X>1Ljnx84?(re$(e1}ySJh3$R zerPi8$YA8#gY;EE&Z=phB8coCVmOA6pVfQlHq%4H)1=^NM|lAS+toIygi)|ztJ4e< zXHIU_P;B3(=p@&mDoCh&f3=P6m)kHO_{dyfI%{Ar{K-(u(g&m;d^Gtp@FW2JH+}?P zAyR^`Y=NoCdPA|DUDX#SPgoc5eZC|rBv+nT@8?!7|Hix6Ka$0Ii9KDKn3z=mRdZn> z7uaoX)1}piBMR09RU!lUYbP~LoBg4XrU7`d7mkjji2D&Tp`Oq`91Hoe*6fs4@F`)I zfsMjnM$?yu8yINM3(S?fbLI!%I-}Ip2eyJM$OVk`Vt58gma&M0rFq<~zM3+hb#|jx z3QkrIa=PYk-RpB8bNH=AM$VP&9jZ*eN(|Rl2DeL(`%ct&Q|aUN=~RK~d^n8rn1;uW zR?MnJdxCQ5Sve}rz@ZXW)?>zG#9Toa(omaMp+qi0(n>ji1?lA)PB$4CuYLPY2aUQ+ z5&q_G&U@!Sn-7WVa0^J1nYJ znj6E>j?`@R_BSH?|D3FK zw0J60%Tt4lC@_Z|9QM1PbZzh7c zQyn}6Y#|@Nw*I+J45)GuzN5eoLBJ!V*eq59!&lr-)jA%%e^}6PTER!jikWHnKFd=2 zfK%7SOUPptgADOn93w8BV<;#!U7C5kE=qZn(T;jKNYT8&%MRbR)$5aYh;QmtP;o$W zpf;t$dqMX5kMCa3d|B{j#~r&Kg05HMj^Xy}?NWXlzP|YQ$k+At3fgQOIM(buwo^)a zPIH89m(nT7WZQ+=sjS5KckvMAFXm34y2Xs@?F@#&hDP7`9NVc`2f}#+ffvgpi4DEx0pA0z0*V8^OFm#Ky`cbwbNMLMaA z@eKcb%?-}AH)@ylGcN5>*zW%BUjCJ8SK!! zUQwq)RXi{+^-KBjI?L*P0S5k)%`XemYp*10`o{w5DXDFe{Q|cnkmB*nB=^WqTRCi~ zE$$bQWWNgM&;KIYBgtDt|9IQwopwhfwqop;3f1zh$xJlu?M!)e zYmmb~Vn?sZ?&pXbz& z&C@ClB21mQ)Op-Um<^ZfKF6A^=a}k3o%`9j6-7r{leRcn4;<~ut8BjP^Uo>E+^kjw zQMRG0=?q=$D<&2@UXDL{8||Ry(^DUlx8_G%o^5+t&Atd1Ln|_CG{AF>e#Ik z6Ie|HxZ;~89IC88`3kztB`BYB>-3x@k+Z-s)@KxrzXu>^*h8^7b!fj07|TjBzd>cO znxBff45wL5qxVRPen`G~o3pZz`AO(^tY&0^!PEKV_`ORV-^%igwkru%ta_Qmw z_p04(Mp9~Ny|HD&IEQGvIPzj6zs1>NAy^@Ehp@YcY^7_EVerOe81D;2PLG*~E-7;= za2BzlDkedMwXm@nK_B}F_HsAtW4$+sP4$KWua7+~CUI%Fy zEEjw2gPw7>oZ+M`%jX|hBn}njia>6hQ`*9qZs^!B_r#@ac~XZ2mEo5-qoq1C30q21 z8acZ2KPu}7kE)wLMI17PSR!*KbrYxFNsLjkt_7del4Z z!H&+QyCbK_`4ToOfY-l$PCptmEIPexj*tIxy{L?gAphL&!HmVv%woTTvaBotp=q|X z*z6uf?i$-WiH6)h%?8Dm^ZcG`%O=D&OaPaY58I46m6Fk&#zRpHA5OAh1(I0qZ{Ih)6_pSkAXLmGOlp^AV$WRwUTw?^;S1q01E1 zO(NcRD|J+G21Jv$O$w}_#E9epz0WLCO_oMoG*(e1(AC^Q2WCrhou0^|HAmcqUh!^s zbzaWyy#9AS6ZN`^BfNuz4r|WYW_X!j@*KN?U z(?V7^2l);&dfuK$FHnXwQ!8n>@OXz8^Fx=-eI7i1lGw@d1AFc1u?F?xo8KaaV+5zc zK)O@FeR##$3hUR^^ZGuE@mgfZzI14h(1N_@=U#JT=@dWld=OxjW?Q@pOfQ^SpOky= zkK6rvnWsR^M8*{uuwIn^l8Hq4>jB22Z|iMsCocH-8-3G8b6qq_hZs+?n_IyJ?)?Or zosvToY!|D<{pTlob`0yu_B(SGe>jCxw)K`*2jXWc%0%2FtG*ukTzu�=wCV}FyLd*yR|<}(tmk(*UgsFb{8td!HT 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

*6P~+u0_V9 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

32lv1CMP^oT0Bf-k$Qu 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%0DpDT}Zh-95L`ZnCQ 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

i7Zf|LUMmrwY(72|2DH)eXI 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 Date: Wed, 4 Nov 2026 16:33:55 +0800 Subject: [PATCH 08/18] docs(540): use final recovery-sequence diagram (#540) --- core/docs/issues/540/recovery-sequence.png | Bin 194039 -> 192760 bytes 1 file changed, 0 insertions(+), 0 deletions(-) diff --git a/core/docs/issues/540/recovery-sequence.png b/core/docs/issues/540/recovery-sequence.png index fad9c09ffaa797e768e030e219a7cf713245b90f..3b8373f6c2bf3b2216e0e49775cfa4b8043b6d3a 100644 GIT binary patch delta 85061 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 From cf366d781850ac12ec1567d74c0958f12f7aacff Mon Sep 17 00:00:00 2001 From: rain Date: Mon, 9 Nov 2026 22:24:02 +0800 Subject: [PATCH 09/18] fix(daemon): cover the new MountNamed request in the retained-record kind (#543) --- control/crates/layerfs-control/tests/doctor.rs | 1 - control/crates/layerfs-sandbox/src/daemon/pool.rs | 7 +++---- engine/crates/layerfs-daemon/src/application/retained.rs | 1 + 3 files changed, 4 insertions(+), 5 deletions(-) diff --git a/control/crates/layerfs-control/tests/doctor.rs b/control/crates/layerfs-control/tests/doctor.rs index bcb756cca3..7b3eeb9990 100644 --- a/control/crates/layerfs-control/tests/doctor.rs +++ b/control/crates/layerfs-control/tests/doctor.rs @@ -583,7 +583,6 @@ fn exec_records_are_checked_and_left_as_they_are() { std::fs::remove_dir_all(home).unwrap(); } - #[test] fn a_stalled_daemon_endpoint_is_a_bounded_warning_and_starts_nothing() { let home = new_home("stalled"); diff --git a/control/crates/layerfs-sandbox/src/daemon/pool.rs b/control/crates/layerfs-sandbox/src/daemon/pool.rs index 22c6baebf4..b5612d6e15 100644 --- a/control/crates/layerfs-sandbox/src/daemon/pool.rs +++ b/control/crates/layerfs-sandbox/src/daemon/pool.rs @@ -12,9 +12,7 @@ //! before it is refused `Busy`. Opening a connection is not an attempt //! of any operation: nothing is sent before the connection is ready. use crate::internal::Control; -use layerfs_bridge::control::{ - DaemonPhase, HelloRequest, Reply, Request, SdkRefusal, SdkValue, -}; +use layerfs_bridge::control::{DaemonPhase, HelloRequest, Reply, Request, SdkRefusal, SdkValue}; use layerfs_bridge::duplex::{ admission::{AdmissionNotice, AdmissionReason}, initiate_observed, ChannelError, @@ -210,7 +208,8 @@ impl Dial { .saturating_duration_since(Instant::now()) .max(Duration::from_millis(1)) }; - let stream = std::net::TcpStream::connect_timeout(&self.endpoint, remaining()).map_err(failed)?; + let stream = + std::net::TcpStream::connect_timeout(&self.endpoint, remaining()).map_err(failed)?; stream.set_read_timeout(Some(remaining())).map_err(failed)?; stream .set_write_timeout(Some(remaining())) diff --git a/engine/crates/layerfs-daemon/src/application/retained.rs b/engine/crates/layerfs-daemon/src/application/retained.rs index 137129a084..f7697d4030 100644 --- a/engine/crates/layerfs-daemon/src/application/retained.rs +++ b/engine/crates/layerfs-daemon/src/application/retained.rs @@ -242,6 +242,7 @@ fn kind(request: &layerfs_bridge::control::Request) -> &'static str { use layerfs_bridge::control::Request; match request { Request::Mount { .. } => "mount", + Request::MountNamed { .. } => "mount", Request::Commit(_) => "commit", Request::Status(_) => "status", Request::Unmount(_) => "unmount", From aca50df03f514fcdde0b873d8b4e9afbdd299897 Mon Sep 17 00:00:00 2001 From: rain Date: Mon, 9 Nov 2026 22:28:15 +0800 Subject: [PATCH 10/18] test: keep the base's already-fixed fixtures exactly (#543) --- api/crates/layerfs-api/tests/workspace_names.rs | 3 +-- engine/crates/layerfs-persistence/tests/sqlite_publication.rs | 2 +- 2 files changed, 2 insertions(+), 3 deletions(-) diff --git a/api/crates/layerfs-api/tests/workspace_names.rs b/api/crates/layerfs-api/tests/workspace_names.rs index 0c0ad51205..b26c44a82b 100644 --- a/api/crates/layerfs-api/tests/workspace_names.rs +++ b/api/crates/layerfs-api/tests/workspace_names.rs @@ -41,8 +41,7 @@ fn home_with_a_named_workspace(tag: &str) -> PathBuf { &SdkValue::map([("name", t("app")), ("created", SdkValue::Int(1))]), ) .unwrap(); - // the native daemon a call would launch: never started here, but the - // record must name a file so the call reaches the Sandbox itself + // the native daemon a call would launch: never started here let native = paths::machine_record(&home, "native"); // (a home made without the machine calls has no native record yet) let record = read_record(&native) diff --git a/engine/crates/layerfs-persistence/tests/sqlite_publication.rs b/engine/crates/layerfs-persistence/tests/sqlite_publication.rs index 16a9729ab9..faf287ca8d 100644 --- a/engine/crates/layerfs-persistence/tests/sqlite_publication.rs +++ b/engine/crates/layerfs-persistence/tests/sqlite_publication.rs @@ -54,7 +54,7 @@ fn unit(pack_id: i64, objects: usize) -> Publication { } } #[test] -fn wal_full_settings_are_explicit() { +fn wal_full_settings_and_unavailable_engine_are_explicit() { let t = Temp::new("durable-profile"); let path = t.join("db"); // without the `postgresql` feature a PostgreSQL selection is unavailable From 403c70eab6b54445a1ee15da267b811b38eba3fd Mon Sep 17 00:00:00 2001 From: rain Date: Mon, 9 Nov 2026 22:37:40 +0800 Subject: [PATCH 11/18] fix(home): widen statvfs blocks through u128 to avoid a Linux-only useless-conversion lint (#543) --- control/crates/layerfs-home/src/home/capacity.rs | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/control/crates/layerfs-home/src/home/capacity.rs b/control/crates/layerfs-home/src/home/capacity.rs index 6e01258759..d57e1354bc 100644 --- a/control/crates/layerfs-home/src/home/capacity.rs +++ b/control/crates/layerfs-home/src/home/capacity.rs @@ -5,7 +5,11 @@ use std::path::Path; /// Uses filesystem allocation units, with checked arithmetic; never writes. pub fn filesystem_available(path: &Path) -> std::io::Result { let filesystem = nix::sys::statvfs::statvfs(path).map_err(std::io::Error::from)?; - u64::from(filesystem.blocks_available()) - .checked_mul(filesystem.fragment_size() as u64) - .ok_or_else(|| std::io::Error::other("filesystem available-byte count overflow")) + // `fsblkcnt_t` is `u32` on macOS but `u64` on Linux, so `u64::from` + // is a useless conversion there; widen through `u128` (the same shape + // every other statvfs consumer uses) and narrow back, checked. + let available = + u128::from(filesystem.blocks_available()) * u128::from(filesystem.fragment_size()); + u64::try_from(available) + .map_err(|_| std::io::Error::other("filesystem available-byte count overflow")) } From d788cc0a2fa61f3294fae993d4dae019d53f2e04 Mon Sep 17 00:00:00 2001 From: rain Date: Mon, 9 Nov 2026 22:45:48 +0800 Subject: [PATCH 12/18] test(doctor): silence the macOS-only native binding on Linux (#543) --- control/crates/layerfs-control/tests/doctor_machine_target.rs | 1 + 1 file changed, 1 insertion(+) diff --git a/control/crates/layerfs-control/tests/doctor_machine_target.rs b/control/crates/layerfs-control/tests/doctor_machine_target.rs index 67a0e08723..fa1c426e02 100644 --- a/control/crates/layerfs-control/tests/doctor_machine_target.rs +++ b/control/crates/layerfs-control/tests/doctor_machine_target.rs @@ -106,6 +106,7 @@ fn machine_target_reports_dependencies_and_preserves_home() { "fail", ); MachineRecord::built_in("native").write(&f.home).unwrap(); + #[cfg_attr(not(target_os = "macos"), allow(unused_variables))] let native = f.report("native", Duration::from_secs(1)); #[cfg(target_os = "macos")] outcome(&native, "machine.provider", "pass"); From 5002922ea1a4c4204617f77d1913bd433f5781d6 Mon Sep 17 00:00:00 2001 From: liuyuchen <152110621+jiangkoumo@users.noreply.github.com> Date: Wed, 11 Nov 2026 13:41:40 +0800 Subject: [PATCH 13/18] feat(sandbox): expose the daemon's control capacity in sandbox.get (#540) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit `sandbox.get` now carries `daemon_capacity`: the daemon's `backend.daemon.connection_failures` read model, the one `layerfs doctor` explains and its fix text already pointed at. The field is best-effort and bounded to 2 s: the query runs in its own thread behind a hard wall, so a daemon that accepts and stalls cannot hold the read, and a daemon that does not answer (stopped, gone, at no known endpoint, or holding no vacant control slot) leaves the field out instead of failing `sandbox.get`. The field is only added for a running Sandbox, and nothing is started to find out. The one query itself moved out of the doctor into `layerfs_sandbox::daemon::capacity` (`endpoint`, `read`, `OPERATION`, `WAIT`), so the doctor and the read model share one implementation: where the daemon is, how long an answer may take, and what an unanswered query is are decided once. Tests: layerfs-api --test sandbox_capacity 2 passed — a stand-in daemon's model reaches `sandbox.get` with its admission counts and retained failure record, and a daemon that reads the query and never answers leaves the field out after the bounded wait while the get still answers. layerfs-control --test doctor unchanged and passing (6 passed). Clippy -D warnings clean on layerfs-api, layerfs-control, layerfs-bridge and layerfs-sandbox; no test failures in those four or layerfs-daemon. Production LOC: 156991 -> 157011 (delta +20); api 4966 -> 4975 (+9), control +11. Counted with tools/production_loc.py over core/crates/*/src, engine/crates/*/src, control/crates/*/src and api/crates/*/src (tests, docs, manifests and generated artifacts excluded). --- api/crates/layerfs-api/src/sandbox/get.rs | 16 +- .../layerfs-api/tests/sandbox_capacity.rs | 290 ++++++++++++++++++ .../layerfs-control/src/doctor/capacity.rs | 88 +----- .../layerfs-sandbox/src/daemon/capacity.rs | 90 ++++++ .../crates/layerfs-sandbox/src/daemon/mod.rs | 2 + 5 files changed, 404 insertions(+), 82 deletions(-) create mode 100644 api/crates/layerfs-api/tests/sandbox_capacity.rs create mode 100644 control/crates/layerfs-sandbox/src/daemon/capacity.rs diff --git a/api/crates/layerfs-api/src/sandbox/get.rs b/api/crates/layerfs-api/src/sandbox/get.rs index f1e05b8467..6d46def847 100644 --- a/api/crates/layerfs-api/src/sandbox/get.rs +++ b/api/crates/layerfs-api/src/sandbox/get.rs @@ -5,6 +5,7 @@ use crate::calls::Context; use layerfs_bridge::control::SdkValue; use layerfs_home::home::with_field; use layerfs_home::outcome::{Outcome, View}; +use layerfs_sandbox::daemon::capacity; use layerfs_sandbox::family::{get, GetRequest, Page}; /// Its table entry. @@ -19,7 +20,9 @@ pub(crate) const CALL: Call = call( /// Runs `sandbox.get`: its record with its derived `state`, one page of /// its `workspaces` (each with its `path`, `name` and `ws`), why its -/// machine did not answer (`down_reason`) and `next_page_pos`. +/// machine did not answer (`down_reason`), the daemon's +/// `daemon_capacity` read model when it answers within +/// [`capacity::WAIT`] (#540), and `next_page_pos`. fn run(context: &mut Context<'_>, args: &SdkValue) -> Outcome { let request = GetRequest { name: args.get_text("name").unwrap_or("").to_owned(), @@ -30,6 +33,14 @@ fn run(context: &mut Context<'_>, args: &SdkValue) -> Outcome { }; let (home, events) = context.parts(); let got = get(home, events, &request)?; + // best-effort and bounded: a daemon that does not answer (stopped, gone, + // at no known endpoint, or holding no vacant control slot) leaves the + // field out and never fails the read + let daemon_capacity = match got.state { + "running" => capacity::endpoint(home, &got.record) + .and_then(|endpoint| capacity::read(home, &got.record, endpoint).ok()), + _ => None, + }; let workspaces = got.workspaces.into_iter().map(|listed| { let item = with_field(listed.item, "path", SdkValue::Text(listed.path)); let item = with_field(item, "name", SdkValue::opt_text(listed.name)); @@ -41,6 +52,9 @@ fn run(context: &mut Context<'_>, args: &SdkValue) -> Outcome { if let Some(why) = got.down_reason { shown = with_field(shown, "down_reason", SdkValue::Text(why)); } + if let Some(model) = daemon_capacity { + shown = with_field(shown, "daemon_capacity", model.to_sdk()); + } let next = super::list::next_page_pos(got.next); Ok(with_field(shown, "next_page_pos", next)) } diff --git a/api/crates/layerfs-api/tests/sandbox_capacity.rs b/api/crates/layerfs-api/tests/sandbox_capacity.rs new file mode 100644 index 0000000000..b9b813adaf --- /dev/null +++ b/api/crates/layerfs-api/tests/sandbox_capacity.rs @@ -0,0 +1,290 @@ +//! `sandbox.get`'s `daemon_capacity` (#540): the daemon's +//! `backend.daemon.connection_failures` read model, shown best-effort and +//! bounded the same way the doctor reads it. Nothing runs: a stand-in +//! daemon answers the Sandbox's Workspace list and its capacity model, a +//! second one answers the list and then says nothing. +#![cfg(unix)] +use layerfs_api::home::{self, paths, write_record}; +use layerfs_bridge::control::{ + AdmissionModel, Answer, Call, DaemonPhase, DaemonStatus, Reply, Request, RetainedModel, + SdkValue, CAPACITY_OPERATION, +}; +use layerfs_bridge::duplex; +use std::net::{SocketAddr, TcpListener}; +use std::os::unix::fs::PermissionsExt; +use std::path::{Path, PathBuf}; +use std::time::{Duration, Instant}; + +const CLIENT_PRIVATE: [u8; 32] = [2; 32]; +const DAEMON_PRIVATE: [u8; 32] = [1; 32]; +const DAEMON_INSTANCE: [u8; 32] = [3; 32]; + +fn tempdir(tag: &str) -> PathBuf { + let dir = std::env::temp_dir().join(format!("lfs-scap-{tag}-{}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(&dir).unwrap(); + std::fs::set_permissions(&dir, std::fs::Permissions::from_mode(0o700)).unwrap(); + dir +} + +fn t(s: &str) -> SdkValue { + SdkValue::text(s) +} + +fn call(home: &Path, name: &str, args: &[(&str, SdkValue)]) -> Result { + let args = SdkValue::Map( + args.iter() + .map(|(n, v)| ((*n).to_owned(), v.clone())) + .collect(), + ); + layerfs_api::call(Some(home), name, args, &mut |_| {}).map_err(|r| (r.code, r.message)) +} + +/// What the stand-in daemon answers `sandbox.list_workspaces` with: no +/// Workspaces, like a Sandbox nothing has mounted in. +fn no_workspaces() -> SdkValue { + SdkValue::map([ + ("kind", t("workspaces")), + ("version", SdkValue::Int(1)), + ("workspaces", SdkValue::List(vec![])), + ]) +} + +/// A stand-in daemon at its own loopback port: it answers this Sandbox's +/// Workspace list, then its capacity model with `model`. With `stall` it +/// answers the Workspace list, reads the capacity query and never answers +/// it, which is what a daemon stuck behind its own slots looks like. +fn daemon(model: SdkValue, stall: bool) -> SocketAddr { + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let endpoint = listener.local_addr().unwrap(); + let model = std::sync::Arc::new(model); + std::thread::spawn(move || { + for stream in listener.incoming() { + let Ok(stream) = stream else { return }; + let model = model.clone(); + // one worker per connection: a used list connection stays open + // beside the capacity query's own + std::thread::spawn(move || serve(stream, &model, stall)); + } + }); + endpoint +} + +/// One stand-in connection: its Hello, then each call's answer until the +/// caller closes it. +fn serve(stream: std::net::TcpStream, model: &SdkValue, stall: bool) { + let _ = stream.set_read_timeout(Some(Duration::from_secs(10))); + let _ = stream.set_write_timeout(Some(Duration::from_secs(10))); + let Ok(mut channel) = duplex::accept( + stream, + &DAEMON_PRIVATE, + duplex::public_key(&CLIENT_PRIVATE).unwrap(), + ) else { + return; + }; + while let Ok(bytes) = channel.receive.receive() { + let Ok(call) = Call::decode(bytes) else { break }; + let id = call.id; + let reply = match call.request { + Request::Hello(_) => Reply::Hello(DaemonStatus { + instance: DAEMON_INSTANCE, + phase: DaemonPhase::ControlReady, + overlay_sqlite: Some("3.51.0".into()), + store_sqlite: Some("3.51.0".into()), + }), + Request::Sdk(sdk) if sdk.method == "sandbox.list_workspaces" => { + Reply::Sdk(no_workspaces()) + } + Request::Sdk(sdk) if sdk.method == CAPACITY_OPERATION => { + if stall { + // read but never answered: the caller's own bound, not a + // closed socket, ends its wait + std::thread::sleep(Duration::from_secs(6)); + break; + } + Reply::Sdk(model.clone()) + } + _ => continue, + }; + if channel + .send + .send(&Answer { id, reply }.encode().unwrap()) + .is_err() + { + break; + } + } +} + +/// A record from `fields`, in order. +fn map(fields: &[(&str, SdkValue)]) -> SdkValue { + SdkValue::Map( + fields + .iter() + .map(|(name, value)| ((*name).to_owned(), value.clone())) + .collect(), + ) +} + +/// A home with Store `shop` (project `api`) and Sandbox `s1` on `native`, +/// recorded as a started Sandbox whose daemon this host reaches through the +/// forward `daemon` names; its keys are `endpoint`'s. +fn forwarded_sandbox(home: &Path, endpoint: SocketAddr) { + write_record( + &paths::machine_record(home, "native"), + &map(&[("name", t("native")), ("platform", t("native"))]), + ) + .unwrap(); + // the forward's machine answers: a forward with no recorded process is + // not checked against one + write_record( + &paths::worker_record(home, "native"), + &map(&[("address", t("127.0.0.1:1")), ("secret", t("5e"))]), + ) + .unwrap(); + write_record( + &paths::store_record(home, "shop"), + &map(&[ + ("name", t("shop")), + ("kind", t("sqlite")), + ("binding", SdkValue::Bytes(vec![7; 16])), + ("cursor", SdkValue::Bytes(vec![8; 32])), + ("profile", t("disposable")), + ("machine", t("native")), + ]), + ) + .unwrap(); + write_record( + &paths::project_record(home, "shop", "api"), + &map(&[("name", t("api"))]), + ) + .unwrap(); + write_record( + &paths::sandbox_record(home, "s1"), + &map(&[ + ("name", t("s1")), + ("project", t("shop/api")), + ("machine", t("native")), + ("id", t("s-1")), + ( + "daemon", + map(&[ + ("name", t("lfs-x-s1")), + ( + "forward", + map(&[ + ("address", t(&endpoint.to_string())), + ("machine", t("native")), + ]), + ), + ]), + ), + ]), + ) + .unwrap(); + write_record( + &paths::sandbox_control(home, "s1"), + &map(&[ + ("endpoint", t(&endpoint.to_string())), + ("secret", SdkValue::Bytes(CLIENT_PRIVATE.to_vec())), + ( + "peer", + SdkValue::Bytes(duplex::public_key(&DAEMON_PRIVATE).unwrap().to_vec()), + ), + ("instance", SdkValue::Bytes(DAEMON_INSTANCE.to_vec())), + ]), + ) + .unwrap(); +} + +/// A model with no vacant pool slot and one retained failure. +fn busy() -> SdkValue { + let model = layerfs_bridge::control::CapacityModel { + admission: AdmissionModel { + pool_vacant: 0, + pool_running: 8, + reserved_vacant: 1, + reserved_running: 0, + }, + retained: RetainedModel { + limit: 64, + ttl_ms: 3_600_000, + count: 1, + dropped: 0, + recorded: 1, + failures: vec![layerfs_bridge::control::RetainedFailureModel { + slot: 0, + class: "pool".into(), + generation: 6, + owner: "daemon instance, pid 4, thread layerfs-control-0".into(), + received_bytes: None, + request: Some("unmount".into()), + reply_sent: false, + cause: "control: the kernel control did not answer".into(), + fence_error: None, + diagnostic_error: None, + age_ms: 12, + expires_in_ms: 3_599_988, + }], + }, + }; + model.to_sdk() +} + +#[test] +fn a_running_sandbox_s_get_shows_its_daemon_capacity() { + let endpoint = daemon(busy(), false); + let home = tempdir("shown"); + home::open(&home).unwrap(); + forwarded_sandbox(&home, endpoint); + let got = call(&home, "sandbox.get", &[("name", t("s1"))]).unwrap(); + assert_eq!(got.get_text("state"), Some("running"), "{got:?}"); + let capacity = got + .get("daemon_capacity") + .unwrap_or_else(|| panic!("{got:?}")); + let admission = capacity.get("admission").unwrap(); + assert_eq!(admission.get_int("pool_vacant"), Some(0), "{capacity:?}"); + assert_eq!(admission.get_int("pool_running"), Some(8), "{capacity:?}"); + assert_eq!( + admission.get_int("reserved_vacant"), + Some(1), + "{capacity:?}" + ); + let retained = capacity.get("retained").unwrap(); + assert_eq!(retained.get_int("count"), Some(1), "{capacity:?}"); + assert_eq!(retained.get_int("limit"), Some(64), "{capacity:?}"); + let Some(SdkValue::List(failures)) = retained.get("failures") else { + panic!("{capacity:?}") + }; + assert_eq!(failures.len(), 1, "{capacity:?}"); + assert_eq!( + failures[0].get_text("cause"), + Some("control: the kernel control did not answer") + ); + assert_eq!(failures[0].get_int("generation"), Some(6)); + assert_eq!(failures[0].get_text("request"), Some("unmount")); + std::fs::remove_dir_all(home).unwrap(); +} + +#[test] +fn a_daemon_that_does_not_answer_leaves_daemon_capacity_out() { + let endpoint = daemon(busy(), true); + let home = tempdir("stalled"); + home::open(&home).unwrap(); + forwarded_sandbox(&home, endpoint); + let at = Instant::now(); + let got = call(&home, "sandbox.get", &[("name", t("s1"))]).unwrap(); + let elapsed = at.elapsed(); + // the read model's own bound ends the wait; the get still answers + assert!( + elapsed < Duration::from_secs(4), + "sandbox.get stalled for {elapsed:?}" + ); + assert!( + elapsed >= Duration::from_secs(1), + "the bounded query did not wait: {elapsed:?}" + ); + assert!(got.get("daemon_capacity").is_none(), "{got:?}"); + assert_eq!(got.get_text("state"), Some("running"), "{got:?}"); + std::fs::remove_dir_all(home).unwrap(); +} diff --git a/control/crates/layerfs-control/src/doctor/capacity.rs b/control/crates/layerfs-control/src/doctor/capacity.rs index 6f35cf23c1..f69dda51a1 100644 --- a/control/crates/layerfs-control/src/doctor/capacity.rs +++ b/control/crates/layerfs-control/src/doctor/capacity.rs @@ -5,29 +5,15 @@ //! naming its endpoint and the operation, never an error, because the //! doctor changes nothing and a stopped daemon is a normal state. //! Two more warnings come from the model itself: retained connection -//! failures, and a pool with no vacant control slot. +//! failures, and a pool with no vacant control slot. The one bounded query +//! itself is `layerfs_sandbox::daemon::capacity`, shared with the +//! `daemon_capacity` field `sandbox.get` shows. use super::report::Findings; use super::scan::Scanned; -use layerfs_bridge::control::{CapacityModel, SdkRefusal, SdkValue}; -use layerfs_home::home::paths; -use layerfs_home::outcome::{failed, refused}; -use layerfs_home::secrets; -use layerfs_sandbox::daemon::operator; -use layerfs_sandbox::direct; -use layerfs_sandbox::record::SandboxRecord; +use layerfs_bridge::control::{CapacityModel, SdkRefusal}; +use layerfs_sandbox::daemon::capacity::{endpoint, read, OPERATION, WAIT}; use std::net::SocketAddr; use std::path::Path; -use std::sync::mpsc; -use std::time::Duration; - -/// The daemon's operator read model of control admission and retained -/// connection failures. -const OPERATION: &str = layerfs_bridge::control::CAPACITY_OPERATION; - -/// How long one daemon query may take: connecting, its Hello and its one -/// exchange. Short on purpose: the doctor must not stall behind a daemon -/// that is unreachable, as an ordinary 60 s admission wait would. -const WAIT: Duration = Duration::from_secs(2); /// Queries the daemon of every running Sandbox whose endpoint is known. pub(super) fn check(home: &Path, scanned: &Scanned, findings: &mut Findings) { @@ -43,73 +29,13 @@ pub(super) fn check(home: &Path, scanned: &Scanned, findings: &mut Findings) { // listens, and the doctor starts nothing to find out continue; }; - match probe_bounded(home, sandbox, endpoint) { - Ok(value) => capacity(findings, name, endpoint, &CapacityModel::parse(&value)), + match read(home, sandbox, endpoint) { + Ok(model) => capacity(findings, name, endpoint, &model), Err(refusal) => unanswered(findings, name, endpoint, &refusal), } } } -/// The address of a running Sandbox's daemon when its record names one to -/// this host: a forwarded machine's forward, else the endpoint the start -/// recorded in `control.json`. Nothing is observed or started. -fn endpoint(home: &Path, sandbox: &SandboxRecord) -> Option { - if let Some(forward) = sandbox.daemon().and_then(direct::forward_of) { - return Some(forward); - } - let keys = secrets::daemon_keys(&paths::sandbox_dir(home, sandbox.name())) - .ok() - .flatten()?; - keys.get_text("endpoint")?.parse().ok() -} - -/// [`probe`] under a hard wall: a daemon that accepts a connection and then -/// says nothing must not hold the doctor past [`WAIT`]. -fn probe_bounded( - home: &Path, - sandbox: &SandboxRecord, - endpoint: SocketAddr, -) -> Result { - let home = home.to_owned(); - let sandbox = sandbox.clone(); - let (sent, received) = mpsc::channel(); - std::thread::spawn(move || { - let _ = sent.send(probe(&home, &sandbox, endpoint)); - }); - match received.recv_timeout(WAIT) { - Ok(result) => result, - Err(_) => Err(refused( - "Unavailable", - format!("the daemon did not answer within {}s", WAIT.as_secs()), - )), - } -} - -/// One daemon query: dial its recorded endpoint with its keys for at most -/// [`WAIT`], then read the capacity model once. -fn probe( - home: &Path, - sandbox: &SandboxRecord, - endpoint: SocketAddr, -) -> Result { - let keys = secrets::daemon_keys(&paths::sandbox_dir(home, sandbox.name()))? - .ok_or_else(|| refused("NoSuchSandbox", "the Sandbox has no daemon keys"))?; - let dial = layerfs_sandbox::daemon::pool::Dial { - endpoint, - secret: secrets::key(&keys, "secret")?, - peer: secrets::key(&keys, "peer")?, - instance: secrets::key(&keys, "instance")?, - }; - let mut control = dial.open_within(WAIT)?; - operator::call(&mut control, OPERATION, SdkValue::Null).map_err(|error| match error { - layerfs_sandbox::SdkError::Refused(refusal) => refusal, - layerfs_sandbox::SdkError::Operation(failure) => { - layerfs_sandbox::daemon::values::refusal(&failure).unwrap_or_else(|| failed(failure)) - } - layerfs_sandbox::SdkError::Mount(failure) => failed(failure), - }) -} - /// A daemon that did not answer: a warning naming its endpoint and the /// operation. An exhausted pool is reported from the refusal's admission /// notice, which names its resource and vacant slots; the daemon never diff --git a/control/crates/layerfs-sandbox/src/daemon/capacity.rs b/control/crates/layerfs-sandbox/src/daemon/capacity.rs new file mode 100644 index 0000000000..12fa70907b --- /dev/null +++ b/control/crates/layerfs-sandbox/src/daemon/capacity.rs @@ -0,0 +1,90 @@ +//! A running Sandbox daemon's control-capacity read model (#540): its +//! `backend.daemon.connection_failures` answer, read once, best-effort and +//! bounded. The doctor explains it and `sandbox.get` shows it as +//! `daemon_capacity`; both ask through here so one place decides where the +//! daemon is, how long an answer may take, and what an unanswered query is. +use crate::daemon::{operator, pool::Dial}; +use crate::direct; +use crate::record::SandboxRecord; +use layerfs_bridge::control::{CapacityModel, SdkRefusal}; +use layerfs_home::home::paths; +use layerfs_home::outcome::{failed, refused}; +use layerfs_home::secrets; +use std::net::SocketAddr; +use std::path::Path; +use std::sync::mpsc; +use std::time::Duration; + +/// The daemon's operator read model of control admission and retained +/// connection failures. +pub const OPERATION: &str = layerfs_bridge::control::CAPACITY_OPERATION; + +/// How long one daemon query may take: connecting, its Hello and its one +/// exchange. Short on purpose: a reader must not stall behind a daemon that +/// is unreachable, as an ordinary 60 s admission wait would. +pub const WAIT: Duration = Duration::from_secs(2); + +/// The address of a running Sandbox's daemon when its record names one to +/// this host: a forwarded machine's forward, else the endpoint the start +/// recorded in `control.json`. Nothing is observed or started. +pub fn endpoint(home: &Path, sandbox: &SandboxRecord) -> Option { + if let Some(forward) = sandbox.daemon().and_then(direct::forward_of) { + return Some(forward); + } + let keys = secrets::daemon_keys(&paths::sandbox_dir(home, sandbox.name())) + .ok() + .flatten()?; + keys.get_text("endpoint")?.parse().ok() +} + +/// [`query`] under a hard wall: a daemon that accepts a connection and then +/// says nothing must not hold the caller past [`WAIT`]. +pub fn read( + home: &Path, + sandbox: &SandboxRecord, + endpoint: SocketAddr, +) -> Result { + let home = home.to_owned(); + let sandbox = sandbox.clone(); + let (sent, received) = mpsc::channel(); + std::thread::spawn(move || { + let _ = sent.send(query(&home, &sandbox, endpoint)); + }); + match received.recv_timeout(WAIT) { + Ok(result) => result.map(|value| CapacityModel::parse(&value)), + Err(_) => Err(refused( + "Unavailable", + format!("the daemon did not answer within {}s", WAIT.as_secs()), + )), + } +} + +/// One daemon query: dial its recorded endpoint with its keys for at most +/// [`WAIT`], then read the capacity model once. +fn query( + home: &Path, + sandbox: &SandboxRecord, + endpoint: SocketAddr, +) -> Result { + let keys = secrets::daemon_keys(&paths::sandbox_dir(home, sandbox.name()))? + .ok_or_else(|| refused("NoSuchSandbox", "the Sandbox has no daemon keys"))?; + let dial = Dial { + endpoint, + secret: secrets::key(&keys, "secret")?, + peer: secrets::key(&keys, "peer")?, + instance: secrets::key(&keys, "instance")?, + }; + let mut control = dial.open_within(WAIT)?; + operator::call( + &mut control, + OPERATION, + layerfs_bridge::control::SdkValue::Null, + ) + .map_err(|error| match error { + crate::SdkError::Refused(refusal) => refusal, + crate::SdkError::Operation(failure) => { + crate::daemon::values::refusal(&failure).unwrap_or_else(|| failed(failure)) + } + crate::SdkError::Mount(failure) => failed(failure), + }) +} diff --git a/control/crates/layerfs-sandbox/src/daemon/mod.rs b/control/crates/layerfs-sandbox/src/daemon/mod.rs index 93718cd2d4..137668a150 100644 --- a/control/crates/layerfs-sandbox/src/daemon/mod.rs +++ b/control/crates/layerfs-sandbox/src/daemon/mod.rs @@ -3,6 +3,8 @@ #[doc(hidden)] pub mod call; #[doc(hidden)] +pub mod capacity; +#[doc(hidden)] pub mod channel; #[doc(hidden)] pub mod failure; From 8978c2eb41838c3c52b462b79696da232df3e0f5 Mon Sep 17 00:00:00 2001 From: liuyuchen <152110621+jiangkoumo@users.noreply.github.com> Date: Wed, 11 Nov 2026 13:51:42 +0800 Subject: [PATCH 14/18] test(sandbox): cover the capacity notice a full pool's next client reads (#540) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A daemon whose pool has no vacant slot answers the next connection with its advisory notice before any handshake. This pins what a client makes of it: `Dial::open_within` refuses `Capacity` on resource `daemon_control_slot` with the notice's vacant-slot and retained counts, retryable because nothing was attempted; a daemon that is still starting is `Unavailable` with admission `starting` instead, so a full pool and a starting one stay distinguishable. Measured against a real macOS daemon before this test existed (LP543-PATCH §4): with eight admitted clients holding every pool slot, the ninth raw connection read `notice version=1 reason=NoPoolSlot retained=0 pool_vacant=0 reserved_vacant=1`. Tests: layerfs-sandbox --test pool_admission 2 passed. Clippy -D warnings clean. Production LOC: 157011 -> 157011 (delta 0); a test-only commit. --- .../layerfs-sandbox/tests/pool_admission.rs | 82 +++++++++++++++++++ 1 file changed, 82 insertions(+) create mode 100644 control/crates/layerfs-sandbox/tests/pool_admission.rs diff --git a/control/crates/layerfs-sandbox/tests/pool_admission.rs b/control/crates/layerfs-sandbox/tests/pool_admission.rs new file mode 100644 index 0000000000..cbd9429ffd --- /dev/null +++ b/control/crates/layerfs-sandbox/tests/pool_admission.rs @@ -0,0 +1,82 @@ +//! A daemon's advisory capacity notice (#540) as a client reads it: a +//! daemon whose pool has no vacant slot answers the next connection with +//! the notice before any handshake, so the refusal is `Capacity` naming the +//! resource, the vacant slots and the retained failure count, not a bare +//! EOF. Nothing is sent by the client and nothing is retried, so the caller +//! may try again. A daemon that is still starting says so the same way. +use layerfs_bridge::duplex; +use layerfs_bridge::duplex::admission::{self, AdmissionNotice, AdmissionReason}; +use layerfs_sandbox::daemon::pool::Dial; +use std::io::Read; +use std::net::{SocketAddr, TcpListener}; +use std::time::Duration; + +const CLIENT_PRIVATE: [u8; 32] = [2; 32]; +const DAEMON_PRIVATE: [u8; 32] = [1; 32]; +const DAEMON_INSTANCE: [u8; 32] = [3; 32]; + +/// A daemon that refuses every connection with `notice` before any +/// handshake, exactly as an accept loop does when no slot is vacant: it +/// writes the notice, shuts its write end and drains what the client sent. +fn refusing(notice: AdmissionNotice) -> SocketAddr { + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let endpoint = listener.local_addr().unwrap(); + std::thread::spawn(move || { + for stream in listener.incoming() { + let Ok(mut stream) = stream else { return }; + let _ = stream.set_write_timeout(Some(Duration::from_millis(100))); + let _ = stream.set_read_timeout(Some(Duration::from_millis(50))); + if admission::write(&mut stream, ¬ice).is_err() { + continue; + } + let mut sink = [0u8; 512]; + let _ = stream.read(&mut sink); + } + }); + endpoint +} + +fn dial(endpoint: SocketAddr) -> Dial { + Dial { + endpoint, + secret: CLIENT_PRIVATE, + peer: duplex::public_key(&DAEMON_PRIVATE).unwrap(), + instance: DAEMON_INSTANCE, + } +} + +#[test] +fn a_full_pool_refuses_the_next_client_with_its_counts() { + let endpoint = refusing(AdmissionNotice::new(AdmissionReason::NoPoolSlot, 3, 0, 1)); + let refusal = dial(endpoint) + .open_within(Duration::from_secs(2)) + .err() + .expect("a full pool admits nothing"); + assert_eq!(refusal.code, "Capacity", "{refusal:?}"); + let detail = &refusal.detail; + assert_eq!(detail.get_text("resource"), Some("daemon_control_slot")); + assert_eq!(detail.get_int("pool_vacant"), Some(0)); + assert_eq!(detail.get_int("reserved_vacant"), Some(1)); + assert_eq!(detail.get_int("retained"), Some(3)); + assert_eq!(detail.get_text("admission"), Some("no-pool-slot")); + // nothing was attempted, so a later open is safe + assert!(detail.get_bool("retryable")); + assert!( + refusal.message.contains("no vacant control slot"), + "{refusal:?}" + ); + assert!(refusal.message.contains("3 retained"), "{refusal:?}"); +} + +#[test] +fn a_still_starting_daemon_is_not_a_full_pool() { + let endpoint = refusing(AdmissionNotice::new(AdmissionReason::Starting, 0, 8, 1)); + let refusal = dial(endpoint) + .open_within(Duration::from_secs(2)) + .err() + .expect("a starting daemon admits nothing"); + // its own code and admission, not Capacity: a full pool it is not + assert_eq!(refusal.code, "Unavailable", "{refusal:?}"); + assert_eq!(refusal.detail.get_text("admission"), Some("starting")); + assert!(refusal.detail.get_bool("retryable")); +} From 88c88fbecdb89cd02d696851797aa04edbded01d Mon Sep 17 00:00:00 2001 From: liuyuchen <152110621+jiangkoumo@users.noreply.github.com> Date: Wed, 11 Nov 2026 15:03:22 +0800 Subject: [PATCH 15/18] fix(sandbox): restore the daemon capacity read in sandbox.get (#543) `sandbox.get` shows `daemon_capacity`, the daemon's `backend.daemon.connection_failures` read model, but only through the half of it that survived the `layerfs_v2_0_0` merge (82165e666): the API layer parsed an endpoint and dialed it itself. That half reaches neither a `docker` nor an `apple-container` Sandbox, whose daemon is behind a machine's worker; it dials a forwarded Sandbox's old port after its machine stopped or its forward exited because it skips `direct::check`; and it opened a second control connection per read, so one `sandbox.get` took two of the daemon's slots and, with seven slots held by other clients, reported no capacity at all - the field the doctor's own fix text tells an operator to read. This restores the operation author's design from 7cfe4460e, 52f9c1666 and 31375c942 (all present before that merge, lost when it resolved #540's conflicts): the read is a host operation again (`Call::Capacity`, `backend.daemon.connection_failures`), routed like the Workspace list it follows - `direct::capacity` for a forwarded Sandbox, its machine's worker for the rest - so `native`, `lima`, `docker` and `apple-container` all answer it, and `api/crates/layerfs-api/src/sandbox/get.rs` is a thin shell over the typed `Got` again. It is asked only for a `running` Sandbox whose machine and forward were reached, on the connection the Workspace list lent from the Sandbox's pool (one connection, one slot), within 2 s for admission and for the exchange, and fenced at that deadline (`daemon/fence.rs`, the pattern the doctor's bounded observation uses): a daemon that trickles its handshake or its reply is shut down rather than left holding a thread, a connection or a slot. Doctor behavior and wording are unchanged. Its own query now ends its control session instead of dropping the socket, which the daemon logged as an unexpected end. Docs: `docs/architecture/api/sdk/sandbox/get.md`, `docs/architecture/api/sdk/sandbox/README.md`, `docs/architecture/control/routing/daemon-channel.md`. Production LOC: 157011 -> 157130 (delta +119) Scope and method: first-party production Rust/SQL/JavaScript in core, engine, control and api (tests, fixtures, tools and docs excluded), counted with `tools/production_loc.py` at the parent commit 8978c2eb4 and the committed tree. control 38406 -> 38524 (+118), api 4975 -> 4976 (+1); core 39749 and engine 73881 unchanged. Reference absent (retired R9c; last counted 65,417 at tree 498dd1917812). --- api/crates/layerfs-api/src/sandbox/get.rs | 40 ++++----- .../layerfs-sandbox/src/daemon/capacity.rs | 88 +++++++++++++------ .../layerfs-sandbox/src/daemon/channel.rs | 8 +- .../layerfs-sandbox/src/daemon/fence.rs | 81 +++++++++++++++++ .../crates/layerfs-sandbox/src/daemon/mod.rs | 2 + .../crates/layerfs-sandbox/src/daemon/pool.rs | 28 +++--- control/crates/layerfs-sandbox/src/direct.rs | 20 +++-- .../crates/layerfs-sandbox/src/dispatch.rs | 12 +++ control/crates/layerfs-sandbox/src/get.rs | 39 +++++++- .../crates/layerfs-sandbox/src/host/call.rs | 10 ++- .../crates/layerfs-sandbox/src/host/frame.rs | 3 + docs/architecture/api/sdk/sandbox/README.md | 8 +- docs/architecture/api/sdk/sandbox/get.md | 28 +++++- .../control/routing/daemon-channel.md | 2 +- 14 files changed, 294 insertions(+), 75 deletions(-) create mode 100644 control/crates/layerfs-sandbox/src/daemon/fence.rs diff --git a/api/crates/layerfs-api/src/sandbox/get.rs b/api/crates/layerfs-api/src/sandbox/get.rs index 6d46def847..2839ca84b8 100644 --- a/api/crates/layerfs-api/src/sandbox/get.rs +++ b/api/crates/layerfs-api/src/sandbox/get.rs @@ -5,8 +5,7 @@ use crate::calls::Context; use layerfs_bridge::control::SdkValue; use layerfs_home::home::with_field; use layerfs_home::outcome::{Outcome, View}; -use layerfs_sandbox::daemon::capacity; -use layerfs_sandbox::family::{get, GetRequest, Page}; +use layerfs_sandbox::family::{get, GetRequest, Got, Page}; /// Its table entry. pub(crate) const CALL: Call = call( @@ -18,11 +17,11 @@ pub(crate) const CALL: Call = call( run, ); -/// Runs `sandbox.get`: its record with its derived `state`, one page of -/// its `workspaces` (each with its `path`, `name` and `ws`), why its -/// machine did not answer (`down_reason`), the daemon's -/// `daemon_capacity` read model when it answers within -/// [`capacity::WAIT`] (#540), and `next_page_pos`. +/// Runs `sandbox.get`: its record with its derived `state`, one page of its +/// `workspaces` (each with its `path`, `name` and `ws`), why its machine did +/// not answer (`down_reason`), the daemon's `daemon_capacity` read model when +/// the Sandbox answered it (#540), and `next_page_pos`. The library reads it +/// best effort and bounded, so this layer only shows what it got. fn run(context: &mut Context<'_>, args: &SdkValue) -> Outcome { let request = GetRequest { name: args.get_text("name").unwrap_or("").to_owned(), @@ -32,29 +31,28 @@ fn run(context: &mut Context<'_>, args: &SdkValue) -> Outcome { }, }; let (home, events) = context.parts(); - let got = get(home, events, &request)?; - // best-effort and bounded: a daemon that does not answer (stopped, gone, - // at no known endpoint, or holding no vacant control slot) leaves the - // field out and never fails the read - let daemon_capacity = match got.state { - "running" => capacity::endpoint(home, &got.record) - .and_then(|endpoint| capacity::read(home, &got.record, endpoint).ok()), - _ => None, - }; - let workspaces = got.workspaces.into_iter().map(|listed| { + let Got { + record, + state, + workspaces, + down_reason, + next, + daemon_capacity, + } = get(home, events, &request)?; + let workspaces = workspaces.into_iter().map(|listed| { let item = with_field(listed.item, "path", SdkValue::Text(listed.path)); let item = with_field(item, "name", SdkValue::opt_text(listed.name)); with_field(item, "ws", SdkValue::Text(listed.ws)) }); - let shown = got.record.to_sdk(View::Full); - let shown = with_field(shown, "state", SdkValue::text(got.state)); + let shown = record.to_sdk(View::Full); + let shown = with_field(shown, "state", SdkValue::text(state)); let mut shown = with_field(shown, "workspaces", SdkValue::List(workspaces.collect())); - if let Some(why) = got.down_reason { + if let Some(why) = down_reason { shown = with_field(shown, "down_reason", SdkValue::Text(why)); } if let Some(model) = daemon_capacity { shown = with_field(shown, "daemon_capacity", model.to_sdk()); } - let next = super::list::next_page_pos(got.next); + let next = super::list::next_page_pos(next); Ok(with_field(shown, "next_page_pos", next)) } diff --git a/control/crates/layerfs-sandbox/src/daemon/capacity.rs b/control/crates/layerfs-sandbox/src/daemon/capacity.rs index 12fa70907b..4bf1a3f1a1 100644 --- a/control/crates/layerfs-sandbox/src/daemon/capacity.rs +++ b/control/crates/layerfs-sandbox/src/daemon/capacity.rs @@ -3,17 +3,24 @@ //! bounded. The doctor explains it and `sandbox.get` shows it as //! `daemon_capacity`; both ask through here so one place decides where the //! daemon is, how long an answer may take, and what an unanswered query is. -use crate::daemon::{operator, pool::Dial}; +//! +//! Both reads end at [`WAIT`], and their connection is fenced at that +//! deadline, so a daemon that trickles its handshake or its one reply keeps +//! neither a thread, a connection nor a control slot past it. +use crate::daemon::fence::Fence; +use crate::daemon::pool::{Controls, Dial}; +use crate::daemon::{operator, trace}; use crate::direct; +use crate::internal::Control; use crate::record::SandboxRecord; -use layerfs_bridge::control::{CapacityModel, SdkRefusal}; +use layerfs_bridge::control::{CapacityModel, Request, SdkRefusal, SdkValue}; use layerfs_home::home::paths; use layerfs_home::outcome::{failed, refused}; use layerfs_home::secrets; use std::net::SocketAddr; use std::path::Path; use std::sync::mpsc; -use std::time::Duration; +use std::time::{Duration, Instant}; /// The daemon's operator read model of control admission and retained /// connection failures. @@ -24,6 +31,33 @@ pub const OPERATION: &str = layerfs_bridge::control::CAPACITY_OPERATION; /// is unreachable, as an ordinary 60 s admission wait would. pub const WAIT: Duration = Duration::from_secs(2); +/// The model [`read`] gives: the daemon's answer, parsed once. +pub fn read( + home: &Path, + sandbox: &SandboxRecord, + endpoint: SocketAddr, +) -> Result { + let home = home.to_owned(); + let sandbox = sandbox.clone(); + bounded(WAIT, move || query(&home, &sandbox, endpoint)) + .map(|answer| CapacityModel::parse(&answer)) +} + +/// The daemon's answer to [`OPERATION`] on a connection the Sandbox's pool +/// lends (`sandbox.get`, #543): at most [`WAIT`] for admission and for the +/// exchange, which is fenced at the same deadline, so this read takes no +/// second connection and no second slot of its own. Nothing is sent again, +/// and the connection goes back to the pool (or is closed, when the fence +/// quarantined it). +pub fn lent(controls: &Controls) -> Result { + let deadline = Instant::now() + WAIT; + let mut control = trace::control_within(controls, WAIT)?; + let fence = Fence::channel((control.close_handle().map_err(failed))?, deadline); + let answer = exchange(&mut control); + drop(fence); + answer +} + /// The address of a running Sandbox's daemon when its record names one to /// this host: a forwarded machine's forward, else the endpoint the start /// recorded in `control.json`. Nothing is observed or started. @@ -38,34 +72,33 @@ pub fn endpoint(home: &Path, sandbox: &SandboxRecord) -> Option { } /// [`query`] under a hard wall: a daemon that accepts a connection and then -/// says nothing must not hold the caller past [`WAIT`]. -pub fn read( - home: &Path, - sandbox: &SandboxRecord, - endpoint: SocketAddr, -) -> Result { - let home = home.to_owned(); - let sandbox = sandbox.clone(); +/// says nothing must not hold the caller past [`WAIT`], even where the fence +/// itself cannot be armed. +fn bounded( + within: Duration, + work: impl FnOnce() -> Result + Send + 'static, +) -> Result { let (sent, received) = mpsc::channel(); std::thread::spawn(move || { - let _ = sent.send(query(&home, &sandbox, endpoint)); + let _ = sent.send(work()); }); - match received.recv_timeout(WAIT) { - Ok(result) => result.map(|value| CapacityModel::parse(&value)), + match received.recv_timeout(within) { + Ok(result) => result, Err(_) => Err(refused( "Unavailable", - format!("the daemon did not answer within {}s", WAIT.as_secs()), + format!("the daemon did not answer within {}s", within.as_secs()), )), } } -/// One daemon query: dial its recorded endpoint with its keys for at most -/// [`WAIT`], then read the capacity model once. +/// One daemon query on a connection dialed for it: its recorded endpoint with +/// its keys, for at most [`WAIT`], fenced at the same deadline, then read the +/// capacity model once. fn query( home: &Path, sandbox: &SandboxRecord, endpoint: SocketAddr, -) -> Result { +) -> Result { let keys = secrets::daemon_keys(&paths::sandbox_dir(home, sandbox.name()))? .ok_or_else(|| refused("NoSuchSandbox", "the Sandbox has no daemon keys"))?; let dial = Dial { @@ -74,13 +107,18 @@ fn query( peer: secrets::key(&keys, "peer")?, instance: secrets::key(&keys, "instance")?, }; - let mut control = dial.open_within(WAIT)?; - operator::call( - &mut control, - OPERATION, - layerfs_bridge::control::SdkValue::Null, - ) - .map_err(|error| match error { + let (mut control, fence) = dial.open_within(WAIT)?; + let answer = exchange(&mut control); + // this conversation ends here: a connection dropped instead leaves the + // daemon reading a closed socket, which it logs as an unexpected end + let _ = control.call(Request::EndSession); + drop(fence); + answer +} + +/// The one exchange: the daemon's answer, or the refusal it gave, kept exact. +fn exchange(control: &mut Control) -> Result { + operator::call(control, OPERATION, SdkValue::Null).map_err(|error| match error { crate::SdkError::Refused(refusal) => refusal, crate::SdkError::Operation(failure) => { crate::daemon::values::refusal(&failure).unwrap_or_else(|| failed(failure)) diff --git a/control/crates/layerfs-sandbox/src/daemon/channel.rs b/control/crates/layerfs-sandbox/src/daemon/channel.rs index 9853146c60..eabe0636e3 100644 --- a/control/crates/layerfs-sandbox/src/daemon/channel.rs +++ b/control/crates/layerfs-sandbox/src/daemon/channel.rs @@ -1,7 +1,7 @@ //! One attempted authenticated control exchange, retaining the original unknown. use layerfs_bridge::{ control::{Answer, Call, ControlError, Reply, Request, SdkValue}, - duplex::{ChannelError, ChannelWork, Connection}, + duplex::{ChannelError, ChannelWork, CloseHandle, Connection}, }; use std::fmt; /// One sequential control connection. Concurrent callers may use separate channels. @@ -243,6 +243,12 @@ impl Control { pub fn clear_io_waits(&self) -> Result<(), ChannelError> { self.connection.clear_io_waits() } + /// A clone of this channel's socket for an application-owned fence + /// (`daemon::fence`): it carries no send or replay capability, and + /// shutting it down quarantines the channel. + pub fn close_handle(&self) -> Result { + self.connection.close_handle() + } /// Actual cumulative duplex send/receive work for this connection. pub fn channel_work(&self) -> (ChannelWork, ChannelWork) { (self.connection.send.work(), self.connection.receive.work()) diff --git a/control/crates/layerfs-sandbox/src/daemon/fence.rs b/control/crates/layerfs-sandbox/src/daemon/fence.rs new file mode 100644 index 0000000000..bfb2b9e735 --- /dev/null +++ b/control/crates/layerfs-sandbox/src/daemon/fence.rs @@ -0,0 +1,81 @@ +//! One deadline a control connection cannot outlive (#540, #543). +//! +//! A bounded read that only sets socket timeouts bounds each read and write +//! system call, not the exchange: a daemon that trickles one byte just +//! inside the timeout can hold the reader, its connection and its pool slot +//! far past the time the caller promised. A fence instead holds a clone of +//! the connection's socket and shuts both directions down at one absolute +//! deadline, which ends the blocked call immediately. The doctor's bounded +//! observation (`doctor/sandbox_channel.rs` outside this crate) uses the same +//! pattern. +use layerfs_bridge::duplex::CloseHandle; +use std::net::{Shutdown, TcpStream}; +use std::sync::mpsc; +use std::time::Instant; + +/// What this fence ends at its deadline: a socket cloned from a connection +/// being opened, or the application-owned close handle of an established +/// channel. +enum End { + Socket(TcpStream), + Channel(CloseHandle), +} + +impl End { + fn shut(&self) { + match self { + Self::Socket(socket) => { + let _ = socket.shutdown(Shutdown::Both); + } + // the handle quarantines the channel too, so the pool closes the + // connection instead of lending it again + Self::Channel(handle) => { + let _ = handle.close(); + } + } + } +} + +/// A socket fence, armed at one absolute deadline; its `Drop` cancels the +/// deadline and joins the thread that waits for it. +pub struct Fence { + stop: mpsc::Sender<()>, + thread: Option>, +} + +impl Fence { + /// Arms `socket` (a clone of the connection's) at `deadline`. + pub fn on(socket: TcpStream, deadline: Instant) -> Self { + Self::armed(End::Socket(socket), deadline) + } + + /// Arms established channel `handle` at `deadline`. + pub fn channel(handle: CloseHandle, deadline: Instant) -> Self { + Self::armed(End::Channel(handle), deadline) + } + + fn armed(end: End, deadline: Instant) -> Self { + let (stop, wait) = mpsc::channel(); + let thread = std::thread::spawn(move || { + if matches!( + wait.recv_timeout(deadline.saturating_duration_since(Instant::now())), + Err(mpsc::RecvTimeoutError::Timeout) + ) { + end.shut(); + } + }); + Self { + stop, + thread: Some(thread), + } + } +} + +impl Drop for Fence { + fn drop(&mut self) { + let _ = self.stop.send(()); + if let Some(thread) = self.thread.take() { + let _ = thread.join(); + } + } +} diff --git a/control/crates/layerfs-sandbox/src/daemon/mod.rs b/control/crates/layerfs-sandbox/src/daemon/mod.rs index 137668a150..a9a3eb2000 100644 --- a/control/crates/layerfs-sandbox/src/daemon/mod.rs +++ b/control/crates/layerfs-sandbox/src/daemon/mod.rs @@ -9,6 +9,8 @@ pub mod channel; #[doc(hidden)] pub mod failure; #[doc(hidden)] +pub mod fence; +#[doc(hidden)] pub mod internal; #[doc(hidden)] pub mod operator; diff --git a/control/crates/layerfs-sandbox/src/daemon/pool.rs b/control/crates/layerfs-sandbox/src/daemon/pool.rs index b5612d6e15..4588a3aff8 100644 --- a/control/crates/layerfs-sandbox/src/daemon/pool.rs +++ b/control/crates/layerfs-sandbox/src/daemon/pool.rs @@ -11,6 +11,7 @@ //! has and callers take turns on them, each waiting at most [`LEND_WAIT`] //! before it is refused `Busy`. Opening a connection is not an attempt //! of any operation: nothing is sent before the connection is ready. +use crate::daemon::fence::Fence; use crate::internal::Control; use layerfs_bridge::control::{DaemonPhase, HelloRequest, Reply, Request, SdkRefusal, SdkValue}; use layerfs_bridge::duplex::{ @@ -196,12 +197,14 @@ impl Dial { self.open_admitted(ADMISSION_WAIT) } - /// [`Dial::open`] within `within` (#540 doctor): connecting, the - /// handshake and its Hello must finish inside that time, and the - /// connection keeps those I/O waits for the one bounded call made on - /// it. Nothing is retried and no admission wait applies: a daemon that - /// refuses or does not answer is reported as it came. - pub fn open_within(&self, within: Duration) -> Result { + /// [`Dial::open_within`], with the fence that ends this connection at + /// the same deadline: connecting, the handshake and its Hello must finish + /// inside that time, and a daemon that trickles any of them is shut down + /// at `deadline` rather than kept waiting. The connection keeps those I/O + /// waits for the one bounded call made on it. Nothing is retried and no + /// admission wait applies: a daemon that refuses or does not answer is + /// reported as it came. + pub fn open_within(&self, within: Duration) -> Result<(Control, Fence), SdkRefusal> { let deadline = Instant::now() + within; let remaining = || { deadline @@ -214,6 +217,9 @@ impl Dial { stream .set_write_timeout(Some(remaining())) .map_err(failed)?; + // armed before the handshake: a trickling far side cannot outlive the + // deadline this open promised, and neither can the one call made on it + let fence = Fence::on(stream.try_clone().map_err(failed)?, deadline); let connection = match initiate_observed(stream, &self.secret, self.peer).result { Ok(connection) => connection, Err(ChannelError::Admission(notice)) => return Err(notice_refusal(notice)), @@ -221,14 +227,16 @@ impl Dial { }; // the waits stay: the caller makes exactly one call and drops it let mut control = Control::new(connection); - match control + let hello = control .call(Request::Hello(HelloRequest { expected_instance: Some(self.instance), wait_for_store: false, })) - .map_err(failed)? - { - Reply::Hello(status) if status.phase == DaemonPhase::ControlReady => Ok(control), + .map_err(failed)?; + match hello { + Reply::Hello(status) if status.phase == DaemonPhase::ControlReady => { + Ok((control, fence)) + } _ => Err(refused("StaleSandbox", "saved daemon is not ControlReady")), } } diff --git a/control/crates/layerfs-sandbox/src/direct.rs b/control/crates/layerfs-sandbox/src/direct.rs index 280f7ef3de..f6188b3306 100644 --- a/control/crates/layerfs-sandbox/src/direct.rs +++ b/control/crates/layerfs-sandbox/src/direct.rs @@ -285,22 +285,26 @@ pub fn host(home: &Path, record: &SandboxRecord, target: &Target, message: Messa /// `sandbox.get`'s Workspace list of forwarded Sandbox `record`: a daemon /// that cannot be reached is [`Unreached`], which the get reports as down. pub fn list(home: &Path, record: &SandboxRecord) -> std::result::Result { - match list_workspaces(home, record) { + match served(home, record, Call::ListWorkspaces { path: None }) { Err(refusal) if refusal.code == "Unavailable" => Err(Unreached(refusal)), other => Ok(other), } } -/// `sandbox.list_workspaces` on forwarded Sandbox `record` in this process, -/// under the Store's lease (the Sandbox half of `workspace::direct::call`). -fn list_workspaces(home: &Path, record: &SandboxRecord) -> Outcome { +/// The daemon's control-capacity read model of forwarded Sandbox `record` +/// (#540), on the connection the Workspace list lent from this process's +/// pool for it (#543). A refused or unanswered read is the caller's to omit. +pub fn capacity(home: &Path, record: &SandboxRecord) -> Outcome { + served(home, record, Call::Capacity) +} + +/// Host `call` on forwarded Sandbox `record` in this process, under the +/// Store's lease (the Sandbox half of `workspace::direct::call`). +fn served(home: &Path, record: &SandboxRecord, call: Call) -> Outcome { let home = home.to_path_buf(); let target = resolve::target(&home, record.project().unwrap_or(""))?; let _lease = lease::hold(&home, &target.store)?; - dispatch::call( - host(&home, record, &target, Message::Absent), - Call::ListWorkspaces { path: None }, - ) + dispatch::call(host(&home, record, &target, Message::Absent), call) } /// The Workspaces forwarded Sandbox `record` holds, which its close sends diff --git a/control/crates/layerfs-sandbox/src/dispatch.rs b/control/crates/layerfs-sandbox/src/dispatch.rs index 09f3a68ccf..f610b3bf54 100644 --- a/control/crates/layerfs-sandbox/src/dispatch.rs +++ b/control/crates/layerfs-sandbox/src/dispatch.rs @@ -19,6 +19,9 @@ pub fn call(host: Host, call: Call) -> Outcome { let directory = crate::files::sandbox_dir(&host)?; listed(daemon_backend(&host, &call)?, &directory) } + // the operator view of control admission and retained failures + // (#540): a bounded read model, never a product operation + Call::Capacity => capacity(&host), Call::Create { platform } => crate::lifecycle::create(&host, platform.as_deref()), Call::Close { force, held } => { crate::lifecycle::close(&host, force, held.as_deref().unwrap_or_default()) @@ -103,6 +106,15 @@ fn daemon_backend(host: &Host, call: &Call) -> Outcome { }) } +/// The daemon's `backend.daemon.connection_failures` read model (#540): the +/// connection the Workspace list lent from the Sandbox's pool, under one +/// bound for admission and the exchange (#543). Nothing starts: the caller +/// asks only a Sandbox this process still reaches. +fn capacity(host: &Host) -> Outcome { + let state = registry::sandbox_live(host)?; + crate::daemon::capacity::lent(&state.controls) +} + /// Refuses an invalid Commit `message` before any effect. pub fn checked(message: &Message) -> Result<(), layerfs_bridge::control::SdkRefusal> { match message { diff --git a/control/crates/layerfs-sandbox/src/get.rs b/control/crates/layerfs-sandbox/src/get.rs index 3dbb7b4445..cb8485bd77 100644 --- a/control/crates/layerfs-sandbox/src/get.rs +++ b/control/crates/layerfs-sandbox/src/get.rs @@ -4,7 +4,7 @@ use super::family::{page, sandbox_of, Page}; use super::record::SandboxRecord; use crate::host::Call; use crate::route::reach; -use layerfs_bridge::control::{SdkRefusal, SdkValue}; +use layerfs_bridge::control::{CapacityModel, SdkRefusal, SdkValue}; use layerfs_home::events::Events; use layerfs_machine::worker::Unreached; use std::path::Path; @@ -44,6 +44,9 @@ pub struct Got { pub down_reason: Option, /// The next page's position; `None` after the last. pub next: Option, + /// Its daemon's control-capacity read model (#540), when a running + /// Sandbox answered the bounded read (#543). + pub daemon_capacity: Option, } /// Its record with one page of its Workspaces. Reading never clears an @@ -80,15 +83,47 @@ pub fn get(home: &Path, events: &mut Events<'_>, request: &GetRequest) -> Result Err(Unreached(why)) => (Vec::new(), Some(why.message), false), }; let (workspaces, next) = page(all, request.page); + let state = record.state(gone); + // best effort, bounded, and only for a Sandbox its daemon still serves: + // this read never fails a get (#540, #543) + let down = down_reason.is_some(); + let daemon_capacity = capacity(&home, events, &record, gone, state, down); Ok(Got { - state: record.state(gone), + state, record, workspaces, down_reason, next, + daemon_capacity, }) } +/// The daemon's `backend.daemon.connection_failures` read model of a Sandbox +/// this process still reaches (#540): read once, best effort, and omitted +/// when the Sandbox is gone, is not running, or its machine or forward is +/// already down — a get dials nothing for one of those (#543). +fn capacity( + home: &Path, + events: &mut Events<'_>, + record: &SandboxRecord, + gone: bool, + state: &str, + down: bool, +) -> Option { + if gone || down || state != "running" { + return None; + } + record.id()?; + // the forwarded daemon is dialed from here, its machine's from its worker: + // either route reads it with the connection the Workspace list lent + let answer = if direct::forwarded(record) { + direct::capacity(home, record) + } else { + reach(home, events, record, Call::Capacity, crate::dispatch::call).ok()? + }; + Some(CapacityModel::parse(&answer.ok()?)) +} + /// Workspace `item` of Sandbox `sandbox`, as its daemon answered it. fn listed_workspace(sandbox: &str, item: &SdkValue) -> ListedWorkspace { let path = (item.get_text("path")) diff --git a/control/crates/layerfs-sandbox/src/host/call.rs b/control/crates/layerfs-sandbox/src/host/call.rs index f3263bcb67..92ced5f1d5 100644 --- a/control/crates/layerfs-sandbox/src/host/call.rs +++ b/control/crates/layerfs-sandbox/src/host/call.rs @@ -19,6 +19,9 @@ pub enum Op { SandboxClose, /// `sandbox.list_workspaces`: its daemon's Workspace list. ListWorkspaces, + /// `backend.daemon.connection_failures`: its daemon's control-capacity + /// read model (#540), a bounded operator read. + Capacity, /// `workspace.mount`. Mount, /// `workspace.exec`. @@ -35,10 +38,11 @@ pub enum Op { /// Every host operation and the name a request carries (`op`). A /// machine's worker runs exactly these. -pub const OPS: [(Op, &str); 9] = [ +pub const OPS: [(Op, &str); 10] = [ (Op::SandboxCreate, "sandbox.create"), (Op::SandboxClose, "sandbox.close"), (Op::ListWorkspaces, "sandbox.list_workspaces"), + (Op::Capacity, layerfs_bridge::control::CAPACITY_OPERATION), (Op::Mount, "workspace.mount"), (Op::Exec, "workspace.exec"), (Op::ExecCancel, "workspace.exec_cancel"), @@ -100,6 +104,9 @@ pub enum Call { }, /// `sandbox.list_workspaces`, with the Workspace `path` it may name. ListWorkspaces { path: Option }, + /// `backend.daemon.connection_failures`: its daemon's control-capacity + /// read model (#540). + Capacity, /// `workspace.mount(branch, { name })`. Mount { branch: Option, @@ -149,6 +156,7 @@ impl Call { Self::Create { .. } => Op::SandboxCreate, Self::Close { .. } => Op::SandboxClose, Self::ListWorkspaces { .. } => Op::ListWorkspaces, + Self::Capacity => Op::Capacity, Self::Mount { .. } => Op::Mount, Self::Exec { .. } => Op::Exec, Self::ExecCancel { .. } => Op::ExecCancel, diff --git a/control/crates/layerfs-sandbox/src/host/frame.rs b/control/crates/layerfs-sandbox/src/host/frame.rs index afce72800c..6848360ddc 100644 --- a/control/crates/layerfs-sandbox/src/host/frame.rs +++ b/control/crates/layerfs-sandbox/src/host/frame.rs @@ -81,6 +81,8 @@ fn fields(call: &Call, sent: &Message, sandbox: Option<&str>) -> Vec<(&'static s Call::ListWorkspaces { path } | Call::Status { path } => { fields.extend(path.as_deref().map(|p| ("path", text(p)))) } + // a bounded operator read: it sends no field of its own + Call::Capacity => {} Call::Mount { branch, name } => { fields.push(("branch", opt(branch))); fields.extend(name.as_deref().map(|n| ("name", text(n)))); @@ -248,6 +250,7 @@ fn call(op: Op, more: &SdkValue) -> Call { }, }, Op::ListWorkspaces => Call::ListWorkspaces { path: text("path") }, + Op::Capacity => Call::Capacity, Op::Mount => Call::Mount { branch: text("branch"), name: text("name"), diff --git a/docs/architecture/api/sdk/sandbox/README.md b/docs/architecture/api/sdk/sandbox/README.md index 759acfeacd..d1724454f6 100644 --- a/docs/architecture/api/sdk/sandbox/README.md +++ b/docs/architecture/api/sdk/sandbox/README.md @@ -36,7 +36,7 @@ unique across the home. | --- | --- | --- | --- | --- | | [`create`](create.md) | `project` (Project), `name` (Name), `machine?` (Name) | `image` (Text) | the Sandbox record with `state`; `forward_failed` when a direct daemon forward did not open | its machine: here or `sandbox.host` in the worker | | [`list`](list.md) | `project?` (Project) | `page_size`, `page_pos` (Int) | `{ items: [record], next_page_pos }` | caller's process, home records only | -| [`get`](get.md) | `name` (Name) | `page_size`, `page_pos` | the record with `state`, `workspaces`, `next_page_pos`, and `down_reason` when its machine is down | its machine or its daemon; starts nothing | +| [`get`](get.md) | `name` (Name) | `page_size`, `page_pos` | the record with `state`, `workspaces`, `next_page_pos`, `down_reason` when its machine is down, and `daemon_capacity` when its daemon answers the bounded capacity read | its machine or its daemon; starts nothing | | [`close`](close.md) | `name` (Name) | `force` (Bool) | `{ kind: "Closed", sandbox, unknown, closed }`, or `{ closed, was_gone: true }`, or `{ closed, was, left? }` for a record with no id | its machine: here or `sandbox.host` in the worker | The record is `SandboxRecord::to_sdk` @@ -47,7 +47,11 @@ its stored fields except `v`, `runtime_id` and `daemon`, plus the derived ([`op.rs`](../../../../../control/crates/layerfs-home/src/op.rs)). Each Workspace in `get` carries `ws` (`:` or `:`), `name` and `path` -([`get.rs`](../../../../../control/crates/layerfs-sandbox/src/get.rs)). +([`get.rs`](../../../../../control/crates/layerfs-sandbox/src/get.rs)), and +its `daemon_capacity` is the daemon's `backend.daemon.connection_failures` +read model, read best effort and bounded to 2 s on the connection the +Workspace list already lent +([`daemon/capacity.rs`](../../../../../control/crates/layerfs-sandbox/src/daemon/capacity.rs)). ## Arguments and options diff --git a/docs/architecture/api/sdk/sandbox/get.md b/docs/architecture/api/sdk/sandbox/get.md index 0a91d70c2b..684cff486d 100644 --- a/docs/architecture/api/sdk/sandbox/get.md +++ b/docs/architecture/api/sdk/sandbox/get.md @@ -11,8 +11,8 @@ its daemon holds, without starting anything. | --- | --- | | Family | [sandbox](README.md) | | Library entry | [`sandbox/get.rs`](../../../../../api/crates/layerfs-api/src/sandbox/get.rs) | -| Implemented in | the library entry parses a typed `GetRequest` → `layerfs_sandbox::family::get` → `get::get`, whose typed `Got` it shapes ([`get.rs`](../../../../../control/crates/layerfs-sandbox/src/get.rs)) | -| Runs in | the caller's process; the Workspace list comes from the Sandbox daemon, dialed from here (forwarded or local) or from the machine's worker | +| Implemented in | the library entry parses a typed `GetRequest` → `layerfs_sandbox::family::get` → `get::get`, whose typed `Got` (its `daemon_capacity` included) it shapes ([`get.rs`](../../../../../control/crates/layerfs-sandbox/src/get.rs)) | +| Runs in | the caller's process; the Workspace list and the daemon's capacity read model come from the Sandbox daemon, dialed from here (forwarded or local) or from the machine's worker | ## Signature @@ -58,7 +58,15 @@ layerfs sandbox get [--page-size ] [--page-pos ] head_moved_since_mount, dirty: {inodes, entries}?, pending_merge, revision } ], next_page_pos: int | null, - down_reason?: text } + down_reason?: text, + daemon_capacity?: { admission: { pool_vacant, pool_running, + reserved_vacant, reserved_running }, + retained: { limit, ttl_ms, count, dropped, recorded, + failures: [ { slot, class, generation, owner, + received_bytes, request, reply_sent, + cause, fence_error, + diagnostic_error, age_ms, + expires_in_ms } ] } } } ``` | Field | Kind | Meaning | @@ -70,6 +78,7 @@ layerfs sandbox get [--page-size ] [--page-pos ] | `workspaces[].*` | | the daemon's read model per Workspace: id, namespace, Branch, base Commit and Layer, root, `activity`, dirty counts ([`operator/inspect.rs`](../../../../../engine/crates/layerfs-store-service/src/operator/inspect.rs) `workspace_value`) | | `next_page_pos` | int or null | next page of `workspaces` | | `down_reason` | text | the machine's worker or the forwarded daemon was not reached; `workspaces` is then `[]` | +| `daemon_capacity` | record | the daemon's `backend.daemon.connection_failures` read model ([#540](https://github.com/Ephemeral-AI-Lab/layerfs/issues/540)): control admission by slot class and the bounded retained connection failures that used to hold a slot ([`control_capacity.rs`](../../../../../engine/crates/layerfs-bridge/src/control_capacity.rs)). It is read once, best effort, and only for a Sandbox that is `running` and whose machine and forward were reached; nothing is started and no second control slot is taken, so the field is simply absent when the daemon refuses, does not answer within 2 s, or was not asked ([`daemon/capacity.rs`](../../../../../control/crates/layerfs-sandbox/src/daemon/capacity.rs)) | ## Where it runs @@ -86,10 +95,21 @@ layerfs sandbox get [--page-size ] [--page-pos ] v Unreached / Unavailable --> record + workspaces [] + down_reason NoSuchSandbox --> state "lost", workspaces [] + + running and not down, same route and the same pooled connection: + backend.daemon.connection_failures --> daemon_capacity (2 s, best effort) ``` `get` starts no machine and loads no image (#535 P4); reading never clears -an intent. See the [routing table](../../../control/routing/routing-table.md) and the +an intent. The capacity read is a second host operation on the connection +the Workspace list lent from the Sandbox's pool +([`daemon/pool.rs`](../../../../../control/crates/layerfs-sandbox/src/daemon/pool.rs)), +bounded to 2 s for admission and for +the exchange and fenced at that deadline ([`daemon/fence.rs`](../../../../../control/crates/layerfs-sandbox/src/daemon/fence.rs)), +so a daemon that trickles cannot hold the slot; a forwarded daemon's forward +and its machine are checked before it is dialed (`direct::check`), so a +stopped machine is `down_reason` and never a 2 s wait on a reused port. See +the [routing table](../../../control/routing/routing-table.md) and the [daemon channel](../../../control/routing/daemon-channel.md). ## Errors diff --git a/docs/architecture/control/routing/daemon-channel.md b/docs/architecture/control/routing/daemon-channel.md index a788b0c3ad..7103015780 100644 --- a/docs/architecture/control/routing/daemon-channel.md +++ b/docs/architecture/control/routing/daemon-channel.md @@ -82,7 +82,7 @@ opening a connection sends only Hello, so it attempts no operation. | `workspace.commit` | `Commit` | `values::commit`: Committed, Merged (with `merged`), or `Conflict` | [`daemon/workspace/commit.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/workspace/commit.rs), [`daemon/values.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/values.rs) | | `workspace.unmount` | `Unmount{token, discard}`, or `ForceUnmount` with `force` | `values::unmounted` (`Dirty` refusal) or `force_unmounted` | [`daemon/workspace/unmount.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/workspace/unmount.rs) | | `workspace.status` | `Status(token)`; the Branch head is read separately on the Store's route | `values::status` | [`daemon/workspace/status.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/workspace/status.rs) | -| `sandbox.get` Workspace list | SDK method `sandbox.list_workspaces`, the one daemon backend method sent | `sandbox/dispatch.rs` | [`daemon/operator.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/operator.rs) | +| `sandbox.get` | SDK method `sandbox.list_workspaces`, then, on the same pooled connection and for a running Sandbox its machine still reaches, `backend.daemon.connection_failures` (`daemon_capacity`, bounded to 2 s: admission and the exchange share one deadline, fenced by [`daemon/fence.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/fence.rs)) | `sandbox/dispatch.rs` (both through `daemon/operator.rs`) | [`daemon/operator.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/operator.rs), [`daemon/capacity.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/capacity.rs) | | `workspace.exec` | none on this channel: `bash -c` runs through the Sandbox's runtime | — | [`exec/run.rs`](../../../../control/crates/layerfs-sandbox/src/exec/run.rs) | `Locate` and `Cleanup` are read-only observations for a caller whose From 811f59e02f6e8dbee8115ed343da337316d04728 Mon Sep 17 00:00:00 2001 From: liuyuchen <152110621+jiangkoumo@users.noreply.github.com> Date: Wed, 11 Nov 2026 15:03:47 +0800 Subject: [PATCH 16/18] test(sandbox): cover the capacity read's routes, wall and pool slot (#543) `sandbox.get`'s `daemon_capacity` (#540) had one test of the shown answer and one of the 2 s bound, both on a forwarded Sandbox. This covers what the restored route decides: - `api/crates/layerfs-api/tests/sandbox_capacity.rs`: the Workspace list and the capacity read share one connection (the stand-in daemon counts them), a stopped machine with no worker record, an ended forward with a recorded process, and a Sandbox with no id are never dialed and answer in well under a second, and a daemon that reads the query and never answers still returns the get at its bound. - `control/crates/layerfs-sandbox/tests/capacity_read.rs`: a query ends its control session (`EndSession`) instead of dropping the socket, a trickling daemon is fenced at the deadline (its own write fails, so the connection was shut down), two pooled reads take the one connection the pool holds, and the host operation a machine's worker runs (`dispatch::call`, `Call::Capacity`) returns the model. - `control/crates/layerfs-sandbox/tests/host_frame.rs`: the `sandbox.host` frame carries `backend.daemon.connection_failures` and reads back as `Call::Capacity`. Production LOC: 157130 -> 157130 (delta 0) Scope and method: first-party production Rust/SQL/JavaScript in core, engine, control and api (tests, fixtures, tools and docs excluded), counted with `tools/production_loc.py` at the parent commit 88c88fbec and the committed tree; this commit changes tests only, so the production total is unchanged. Reference absent (retired R9c; last counted 65,417 at tree 498dd1917812). --- .../layerfs-api/tests/sandbox_capacity.rs | 183 +++++++---- .../layerfs-sandbox/tests/capacity_read.rs | 300 ++++++++++++++++++ .../layerfs-sandbox/tests/host_frame.rs | 1 + 3 files changed, 430 insertions(+), 54 deletions(-) create mode 100644 control/crates/layerfs-sandbox/tests/capacity_read.rs diff --git a/api/crates/layerfs-api/tests/sandbox_capacity.rs b/api/crates/layerfs-api/tests/sandbox_capacity.rs index b9b813adaf..feb60971a2 100644 --- a/api/crates/layerfs-api/tests/sandbox_capacity.rs +++ b/api/crates/layerfs-api/tests/sandbox_capacity.rs @@ -1,8 +1,10 @@ -//! `sandbox.get`'s `daemon_capacity` (#540): the daemon's +//! `sandbox.get`'s `daemon_capacity` (#540, #543): the daemon's //! `backend.daemon.connection_failures` read model, shown best-effort and -//! bounded the same way the doctor reads it. Nothing runs: a stand-in -//! daemon answers the Sandbox's Workspace list and its capacity model, a -//! second one answers the list and then says nothing. +//! bounded on the connection the Workspace list lent from this process's +//! pool. Nothing runs: a stand-in daemon answers the Sandbox's Workspace list +//! and its capacity model on the same connection, a second one answers the +//! list and then says nothing, and a Sandbox whose machine or forward is +//! already down is not dialed at all. #![cfg(unix)] use layerfs_api::home::{self, paths, write_record}; use layerfs_bridge::control::{ @@ -13,14 +15,21 @@ use layerfs_bridge::duplex; use std::net::{SocketAddr, TcpListener}; use std::os::unix::fs::PermissionsExt; use std::path::{Path, PathBuf}; +use std::sync::atomic::{AtomicUsize, Ordering}; +use std::sync::Arc; use std::time::{Duration, Instant}; const CLIENT_PRIVATE: [u8; 32] = [2; 32]; const DAEMON_PRIVATE: [u8; 32] = [1; 32]; const DAEMON_INSTANCE: [u8; 32] = [3; 32]; +/// Names the homes of one test process apart. +static HOMES: AtomicUsize = AtomicUsize::new(0); + fn tempdir(tag: &str) -> PathBuf { - let dir = std::env::temp_dir().join(format!("lfs-scap-{tag}-{}", std::process::id())); + let sequence = HOMES.fetch_add(1, Ordering::Relaxed); + let dir = + std::env::temp_dir().join(format!("lfs-scap-{tag}-{}-{sequence}", std::process::id())); let _ = std::fs::remove_dir_all(&dir); std::fs::create_dir_all(&dir).unwrap(); std::fs::set_permissions(&dir, std::fs::Permissions::from_mode(0o700)).unwrap(); @@ -50,24 +59,27 @@ fn no_workspaces() -> SdkValue { ]) } -/// A stand-in daemon at its own loopback port: it answers this Sandbox's -/// Workspace list, then its capacity model with `model`. With `stall` it -/// answers the Workspace list, reads the capacity query and never answers -/// it, which is what a daemon stuck behind its own slots looks like. -fn daemon(model: SdkValue, stall: bool) -> SocketAddr { +/// A stand-in daemon at its own loopback port, and how many connections it +/// served: it answers this Sandbox's Workspace list and its capacity model +/// with `model` on the connection it was given. With `stall` it answers the +/// Workspace list, reads the capacity query and never answers it, which is +/// what a daemon stuck behind its own slots looks like. +fn daemon(model: SdkValue, stall: bool) -> (SocketAddr, Arc) { let listener = TcpListener::bind("127.0.0.1:0").unwrap(); let endpoint = listener.local_addr().unwrap(); - let model = std::sync::Arc::new(model); + let model = Arc::new(model); + let served = Arc::new(AtomicUsize::new(0)); + let counted = served.clone(); std::thread::spawn(move || { for stream in listener.incoming() { let Ok(stream) = stream else { return }; + counted.fetch_add(1, Ordering::SeqCst); let model = model.clone(); - // one worker per connection: a used list connection stays open - // beside the capacity query's own + // one worker per connection: the pool keeps one and reuses it std::thread::spawn(move || serve(stream, &model, stall)); } }); - endpoint + (endpoint, served) } /// One stand-in connection: its Hello, then each call's answer until the @@ -97,8 +109,8 @@ fn serve(stream: std::net::TcpStream, model: &SdkValue, stall: bool) { } Request::Sdk(sdk) if sdk.method == CAPACITY_OPERATION => { if stall { - // read but never answered: the caller's own bound, not a - // closed socket, ends its wait + // read but never answered: the read model's own fence, not + // a closed socket, ends its wait std::thread::sleep(Duration::from_secs(6)); break; } @@ -126,22 +138,23 @@ fn map(fields: &[(&str, SdkValue)]) -> SdkValue { ) } -/// A home with Store `shop` (project `api`) and Sandbox `s1` on `native`, -/// recorded as a started Sandbox whose daemon this host reaches through the -/// forward `daemon` names; its keys are `endpoint`'s. -fn forwarded_sandbox(home: &Path, endpoint: SocketAddr) { +/// The home's machine, Store `shop` and project `api`; the machine's `worker` +/// record only while it runs (its absence is a stopped machine, #535 D11). +fn home_records(home: &Path, worker: bool) { write_record( &paths::machine_record(home, "native"), &map(&[("name", t("native")), ("platform", t("native"))]), ) .unwrap(); - // the forward's machine answers: a forward with no recorded process is - // not checked against one - write_record( - &paths::worker_record(home, "native"), - &map(&[("address", t("127.0.0.1:1")), ("secret", t("5e"))]), - ) - .unwrap(); + if worker { + // the forward's machine answers: a forward with no recorded process is + // not checked against one + write_record( + &paths::worker_record(home, "native"), + &map(&[("address", t("127.0.0.1:1")), ("secret", t("5e"))]), + ) + .unwrap(); + } write_record( &paths::store_record(home, "shop"), &map(&[ @@ -159,29 +172,33 @@ fn forwarded_sandbox(home: &Path, endpoint: SocketAddr) { &map(&[("name", t("api"))]), ) .unwrap(); - write_record( - &paths::sandbox_record(home, "s1"), - &map(&[ - ("name", t("s1")), - ("project", t("shop/api")), - ("machine", t("native")), - ("id", t("s-1")), - ( - "daemon", - map(&[ - ("name", t("lfs-x-s1")), - ( - "forward", - map(&[ - ("address", t(&endpoint.to_string())), - ("machine", t("native")), - ]), - ), - ]), - ), - ]), - ) - .unwrap(); +} + +/// Sandbox `s1` on `native`, recorded with its `id` (`None`: gone, its create +/// never recorded one) whose daemon this host reaches through the forward to +/// `endpoint`, carried by forward process `pid` (`None`: a port nothing +/// carries). +fn sandbox_record(home: &Path, endpoint: SocketAddr, id: Option<&str>, pid: Option) { + let mut forward = vec![ + ("address", t(&endpoint.to_string())), + ("machine", t("native")), + ]; + if let Some(pid) = pid { + forward.push(("pid", SdkValue::Int(pid))); + } + let mut fields = vec![ + ("name", t("s1")), + ("project", t("shop/api")), + ("machine", t("native")), + ]; + if let Some(id) = id { + fields.push(("id", t(id))); + } + fields.push(( + "daemon", + map(&[("name", t("lfs-x-s1")), ("forward", map(&forward))]), + )); + write_record(&paths::sandbox_record(home, "s1"), &map(&fields)).unwrap(); write_record( &paths::sandbox_control(home, "s1"), &map(&[ @@ -233,10 +250,11 @@ fn busy() -> SdkValue { #[test] fn a_running_sandbox_s_get_shows_its_daemon_capacity() { - let endpoint = daemon(busy(), false); + let (endpoint, served) = daemon(busy(), false); let home = tempdir("shown"); home::open(&home).unwrap(); - forwarded_sandbox(&home, endpoint); + home_records(&home, true); + sandbox_record(&home, endpoint, Some("s-1"), None); let got = call(&home, "sandbox.get", &[("name", t("s1"))]).unwrap(); assert_eq!(got.get_text("state"), Some("running"), "{got:?}"); let capacity = got @@ -263,15 +281,19 @@ fn a_running_sandbox_s_get_shows_its_daemon_capacity() { ); assert_eq!(failures[0].get_int("generation"), Some(6)); assert_eq!(failures[0].get_text("request"), Some("unmount")); + // the Workspace list and the capacity read share the one pooled + // connection (#543): a get takes no second control slot of its own + assert_eq!(served.load(Ordering::SeqCst), 1, "{got:?}"); std::fs::remove_dir_all(home).unwrap(); } #[test] fn a_daemon_that_does_not_answer_leaves_daemon_capacity_out() { - let endpoint = daemon(busy(), true); + let (endpoint, _served) = daemon(busy(), true); let home = tempdir("stalled"); home::open(&home).unwrap(); - forwarded_sandbox(&home, endpoint); + home_records(&home, true); + sandbox_record(&home, endpoint, Some("s-1"), None); let at = Instant::now(); let got = call(&home, "sandbox.get", &[("name", t("s1"))]).unwrap(); let elapsed = at.elapsed(); @@ -288,3 +310,56 @@ fn a_daemon_that_does_not_answer_leaves_daemon_capacity_out() { assert_eq!(got.get_text("state"), Some("running"), "{got:?}"); std::fs::remove_dir_all(home).unwrap(); } + +#[test] +fn a_stopped_machine_is_never_dialed() { + let (endpoint, served) = daemon(busy(), false); + let home = tempdir("stopped"); + home::open(&home).unwrap(); + // the machine records no worker: nothing starts it (#535 D11) + home_records(&home, false); + sandbox_record(&home, endpoint, Some("s-1"), None); + let at = Instant::now(); + let got = call(&home, "sandbox.get", &[("name", t("s1"))]).unwrap(); + let elapsed = at.elapsed(); + assert!(got.get("down_reason").is_some(), "{got:?}"); + assert!(got.get("daemon_capacity").is_none(), "{got:?}"); + // a down machine is answered from its records: no port is dialed and + // nothing waits for a daemon that is not there + assert_eq!(served.load(Ordering::SeqCst), 0, "{got:?}"); + assert!(elapsed < Duration::from_secs(1), "{elapsed:?}"); + std::fs::remove_dir_all(home).unwrap(); +} + +#[test] +fn an_ended_forward_is_never_dialed() { + let (endpoint, served) = daemon(busy(), false); + let home = tempdir("forward-ended"); + home::open(&home).unwrap(); + home_records(&home, true); + // a recorded forward process that is not alive: its port may be reused by + // another process, so it is never dialed + sandbox_record(&home, endpoint, Some("s-1"), Some(3_999_999)); + let at = Instant::now(); + let got = call(&home, "sandbox.get", &[("name", t("s1"))]).unwrap(); + let elapsed = at.elapsed(); + assert!(got.get("down_reason").is_some(), "{got:?}"); + assert!(got.get("daemon_capacity").is_none(), "{got:?}"); + assert_eq!(served.load(Ordering::SeqCst), 0, "{got:?}"); + assert!(elapsed < Duration::from_secs(1), "{elapsed:?}"); + std::fs::remove_dir_all(home).unwrap(); +} + +#[test] +fn a_sandbox_with_no_id_is_never_dialed() { + let (endpoint, served) = daemon(busy(), false); + let home = tempdir("gone"); + home::open(&home).unwrap(); + home_records(&home, true); + sandbox_record(&home, endpoint, None, None); + let got = call(&home, "sandbox.get", &[("name", t("s1"))]).unwrap(); + assert_eq!(got.get_text("state"), Some("gone"), "{got:?}"); + assert!(got.get("daemon_capacity").is_none(), "{got:?}"); + assert_eq!(served.load(Ordering::SeqCst), 0, "{got:?}"); + std::fs::remove_dir_all(home).unwrap(); +} diff --git a/control/crates/layerfs-sandbox/tests/capacity_read.rs b/control/crates/layerfs-sandbox/tests/capacity_read.rs new file mode 100644 index 0000000000..9b5241fbfa --- /dev/null +++ b/control/crates/layerfs-sandbox/tests/capacity_read.rs @@ -0,0 +1,300 @@ +//! The `backend.daemon.connection_failures` read model's bounds (#540, +//! #543): one query ends its control session instead of dropping the socket, +//! a daemon that trickles is fenced at the deadline, and a read on the +//! Sandbox's pool takes no second connection. +//! +//! Nothing runs: a stand-in daemon answers the query on the connections it +//! accepts, and counts what it saw. +use layerfs_bridge::control::{ + AdmissionModel, Answer, Call, CapacityModel, DaemonPhase, DaemonStatus, Reply, Request, + RetainedModel, SdkValue, CAPACITY_OPERATION, +}; +use layerfs_bridge::duplex; +use layerfs_home::home::paths; +use layerfs_home::secrets; +use layerfs_sandbox::daemon::capacity; +use layerfs_sandbox::daemon::pool::{Controls, Dial}; +use layerfs_sandbox::host::{Call as HostCall, Host, Message}; +use layerfs_sandbox::record::SandboxRecord; +use std::io::Write; +use std::net::{SocketAddr, TcpListener, TcpStream}; +use std::os::unix::fs::PermissionsExt; +use std::path::{Path, PathBuf}; +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; +use std::sync::Arc; +use std::time::{Duration, Instant}; + +const CLIENT_PRIVATE: [u8; 32] = [2; 32]; +const DAEMON_PRIVATE: [u8; 32] = [1; 32]; +const DAEMON_INSTANCE: [u8; 32] = [3; 32]; + +/// Names the homes of one test process apart. +static HOMES: AtomicUsize = AtomicUsize::new(0); + +fn tempdir(tag: &str) -> PathBuf { + let sequence = HOMES.fetch_add(1, Ordering::Relaxed); + let dir = + std::env::temp_dir().join(format!("lfs-capr-{tag}-{}-{sequence}", std::process::id())); + let _ = std::fs::remove_dir_all(&dir); + std::fs::create_dir_all(&dir).unwrap(); + std::fs::set_permissions(&dir, std::fs::Permissions::from_mode(0o700)).unwrap(); + dir +} + +fn t(s: &str) -> SdkValue { + SdkValue::text(s) +} + +/// A model of a pool with no vacant slot (and no retained failure). +fn model() -> SdkValue { + CapacityModel { + admission: AdmissionModel { + pool_vacant: 0, + pool_running: 8, + reserved_vacant: 1, + reserved_running: 0, + }, + retained: RetainedModel::default(), + } + .to_sdk() +} + +fn dial(endpoint: SocketAddr) -> Dial { + Dial { + endpoint, + secret: CLIENT_PRIVATE, + peer: duplex::public_key(&DAEMON_PRIVATE).unwrap(), + instance: DAEMON_INSTANCE, + } +} + +/// What a stand-in daemon saw, and how it treats the query. +#[derive(Default)] +struct Seen { + connections: AtomicUsize, + queries: AtomicUsize, + ended: AtomicBool, + fenced: AtomicBool, +} + +/// How the stand-in answers the capacity query. +#[derive(Clone, Copy)] +enum Behavior { + /// With the model. + Model, + /// Never: it trickles one byte every `TRICKLE` until the far side closes + /// the socket (`Seen::fenced`). + Trickle, +} + +const TRICKLE: Duration = Duration::from_millis(400); + +/// A stand-in daemon at its own loopback port. +fn daemon(answer: Behavior) -> (SocketAddr, Arc) { + let listener = TcpListener::bind("127.0.0.1:0").unwrap(); + let endpoint = listener.local_addr().unwrap(); + let seen = Arc::new(Seen::default()); + let counted = seen.clone(); + std::thread::spawn(move || { + for stream in listener.incoming() { + let Ok(stream) = stream else { return }; + counted.connections.fetch_add(1, Ordering::SeqCst); + let seen = counted.clone(); + std::thread::spawn(move || serve(stream, answer, &seen)); + } + }); + (endpoint, seen) +} + +/// One stand-in connection: its Hello, then each call's answer; a query ends +/// the session when the caller sends its end. +fn serve(stream: TcpStream, answer: Behavior, seen: &Seen) { + let _ = stream.set_read_timeout(Some(Duration::from_secs(10))); + let _ = stream.set_write_timeout(Some(Duration::from_secs(10))); + // kept for a trickling daemon: ciphertext is the channel's to write + let mut raw = stream.try_clone().ok(); + let Ok(mut channel) = duplex::accept( + stream, + &DAEMON_PRIVATE, + duplex::public_key(&CLIENT_PRIVATE).unwrap(), + ) else { + return; + }; + while let Ok(bytes) = channel.receive.receive() { + let Ok(call) = Call::decode(bytes) else { break }; + let id = call.id; + let reply = match call.request { + Request::Hello(_) => Reply::Hello(DaemonStatus { + instance: DAEMON_INSTANCE, + phase: DaemonPhase::ControlReady, + overlay_sqlite: Some("3.51.0".into()), + store_sqlite: Some("3.51.0".into()), + }), + Request::EndSession => { + seen.ended.store(true, Ordering::SeqCst); + Reply::SessionEnded + } + Request::Sdk(sdk) if sdk.method == CAPACITY_OPERATION => { + seen.queries.fetch_add(1, Ordering::SeqCst); + if matches!(answer, Behavior::Trickle) { + if let Some(raw) = raw.as_mut() { + trickle(raw, seen); + } + break; + } + Reply::Sdk(model()) + } + _ => continue, + }; + if channel + .send + .send(&Answer { id, reply }.encode().unwrap()) + .is_err() + { + break; + } + } +} + +/// Keeps the far side waiting without ever completing a record, until it ends +/// the connection itself. +fn trickle(raw: &mut TcpStream, seen: &Seen) { + let byte = [0u8; 1]; + for _ in 0..20 { + std::thread::sleep(TRICKLE); + if raw.write_all(&byte).and_then(|()| raw.flush()).is_err() { + seen.fenced.store(true, Ordering::SeqCst); + return; + } + } +} + +/// Sandbox `s1`'s folder in `home`, recording the daemon keys its queries +/// read (`control.json`) and, with `forward`, the record that reaches its +/// daemon through that forward. +fn sandbox_folder(home: &Path, endpoint: SocketAddr, forward: bool) { + let dir = paths::sandbox_dir(home, "s1"); + std::fs::create_dir_all(&dir).unwrap(); + std::fs::set_permissions(&dir, std::fs::Permissions::from_mode(0o700)).unwrap(); + let keys = SdkValue::map([ + ("endpoint", t(&endpoint.to_string())), + ("secret", SdkValue::Bytes(CLIENT_PRIVATE.to_vec())), + ( + "peer", + SdkValue::Bytes(duplex::public_key(&DAEMON_PRIVATE).unwrap().to_vec()), + ), + ("instance", SdkValue::Bytes(DAEMON_INSTANCE.to_vec())), + ]); + secrets::save_daemon_keys(&dir, &keys).unwrap(); + if forward { + let record = SdkValue::map([ + ("name", t("s1")), + ("project", t("shop/api")), + ("machine", t("native")), + ("id", t("s-1")), + ( + "daemon", + SdkValue::map([( + "forward", + SdkValue::map([ + ("address", t(&endpoint.to_string())), + ("machine", t("native")), + ]), + )]), + ), + ]); + layerfs_home::home::records::write_record(&dir.join("record.json"), &record).unwrap(); + layerfs_home::home::records::write_record( + &paths::worker_record(home, "native"), + &SdkValue::map([("address", t("127.0.0.1:1")), ("secret", t("5e"))]), + ) + .unwrap(); + } +} + +fn record(name: &str) -> SandboxRecord { + SandboxRecord::from_record(name, SdkValue::map([])) +} + +#[test] +fn a_query_ends_its_control_session() { + let (endpoint, seen) = daemon(Behavior::Model); + let home = tempdir("session"); + sandbox_folder(&home, endpoint, false); + let got = capacity::read(&home, &record("s1"), endpoint).unwrap(); + assert_eq!(got.admission.pool_running, 8); + // the one conversation ended before the socket was dropped, which the + // daemon would otherwise log as an unexpected end + assert!(seen.ended.load(Ordering::SeqCst), "no EndSession was sent"); + std::fs::remove_dir_all(home).unwrap(); +} + +#[test] +fn a_trickling_daemon_is_fenced_at_the_deadline() { + let (endpoint, seen) = daemon(Behavior::Trickle); + let home = tempdir("trickle"); + sandbox_folder(&home, endpoint, false); + let at = Instant::now(); + let refused = capacity::read(&home, &record("s1"), endpoint).err(); + let elapsed = at.elapsed(); + assert!(refused.is_some(), "{refused:?}"); + assert!( + elapsed < capacity::WAIT + Duration::from_millis(1500), + "the read outlived its deadline: {elapsed:?}" + ); + // the socket was shut down, not merely abandoned: the daemon's own write + // failed + let until = Instant::now() + Duration::from_secs(3); + while !seen.fenced.load(Ordering::SeqCst) && Instant::now() < until { + std::thread::sleep(Duration::from_millis(50)); + } + assert!( + seen.fenced.load(Ordering::SeqCst), + "the fence did not close the connection" + ); + std::fs::remove_dir_all(home).unwrap(); +} + +#[test] +fn a_pooled_read_takes_no_second_connection() { + let (endpoint, seen) = daemon(Behavior::Model); + let dial = dial(endpoint); + let first = dial.open().unwrap(); + let controls = Controls::new(first, dial); + let one = capacity::lent(&controls).unwrap(); + let two = capacity::lent(&controls).unwrap(); + assert_eq!(CapacityModel::parse(&one).admission.pool_vacant, 0); + assert_eq!(CapacityModel::parse(&two).admission.pool_running, 8); + // both reads went over the one connection the pool holds, so a get takes + // a single control slot for the list and the capacity read together + assert_eq!(seen.connections.load(Ordering::SeqCst), 1); + assert_eq!(seen.queries.load(Ordering::SeqCst), 2); +} + +#[test] +fn the_worker_s_side_reads_the_capacity_model() { + let (endpoint, seen) = daemon(Behavior::Model); + let home = tempdir("worker"); + std::fs::create_dir_all(&home).unwrap(); + sandbox_folder(&home, endpoint, true); + // the request a machine's worker decodes (`sandbox.host`) and the host + // operation it runs: no Store is opened and no image is loaded + let host = Host { + home: home.clone(), + store: "shop".to_owned(), + project: "api".to_owned(), + sandbox: Some("s1".to_owned()), + store_record: None, + store_path: None, + deploy: None, + postgresql: None, + message: Message::Absent, + started: None, + }; + let answer = layerfs_sandbox::dispatch::call(host, HostCall::Capacity).unwrap(); + let model = CapacityModel::parse(&answer); + assert_eq!(model.admission.pool_vacant, 0, "{answer:?}"); + assert_eq!(model.admission.reserved_vacant, 1, "{answer:?}"); + assert_eq!(seen.queries.load(Ordering::SeqCst), 1); + std::fs::remove_dir_all(home).unwrap(); +} diff --git a/control/crates/layerfs-sandbox/tests/host_frame.rs b/control/crates/layerfs-sandbox/tests/host_frame.rs index d43a315aa9..a940d00b22 100644 --- a/control/crates/layerfs-sandbox/tests/host_frame.rs +++ b/control/crates/layerfs-sandbox/tests/host_frame.rs @@ -74,6 +74,7 @@ fn a_frame_reads_back_to_its_request() { held: None, }, Call::ListWorkspaces { path: None }, + Call::Capacity, Call::Mount { branch: Some("dev".to_owned()), name: Some("w2".to_owned()), From de009a8b87ffe146f8275ea71337fe89ce5b774d Mon Sep 17 00:00:00 2001 From: liuyuchen <152110621+jiangkoumo@users.noreply.github.com> Date: Wed, 11 Nov 2026 15:09:03 +0800 Subject: [PATCH 17/18] docs(sandbox): cite #540 plainly in sandbox.get's field table (#543) The `daemon_capacity` row linked an issue URL that the guides do not have a record of; it cites the issue the way the surrounding documents do, `(#540)`. Production LOC: 157130 -> 157130 (delta 0) Scope and method: first-party production Rust/SQL/JavaScript in core, engine, control and api (tests, fixtures, tools and docs excluded), counted with `tools/production_loc.py` at the parent commit 811f59e02 and the committed tree; this commit changes one documentation line, so the production total is unchanged. Reference absent (retired R9c; last counted 65,417 at tree 498dd1917812). --- docs/architecture/api/sdk/sandbox/get.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/architecture/api/sdk/sandbox/get.md b/docs/architecture/api/sdk/sandbox/get.md index 684cff486d..7986a6bd07 100644 --- a/docs/architecture/api/sdk/sandbox/get.md +++ b/docs/architecture/api/sdk/sandbox/get.md @@ -78,7 +78,7 @@ layerfs sandbox get [--page-size ] [--page-pos ] | `workspaces[].*` | | the daemon's read model per Workspace: id, namespace, Branch, base Commit and Layer, root, `activity`, dirty counts ([`operator/inspect.rs`](../../../../../engine/crates/layerfs-store-service/src/operator/inspect.rs) `workspace_value`) | | `next_page_pos` | int or null | next page of `workspaces` | | `down_reason` | text | the machine's worker or the forwarded daemon was not reached; `workspaces` is then `[]` | -| `daemon_capacity` | record | the daemon's `backend.daemon.connection_failures` read model ([#540](https://github.com/Ephemeral-AI-Lab/layerfs/issues/540)): control admission by slot class and the bounded retained connection failures that used to hold a slot ([`control_capacity.rs`](../../../../../engine/crates/layerfs-bridge/src/control_capacity.rs)). It is read once, best effort, and only for a Sandbox that is `running` and whose machine and forward were reached; nothing is started and no second control slot is taken, so the field is simply absent when the daemon refuses, does not answer within 2 s, or was not asked ([`daemon/capacity.rs`](../../../../../control/crates/layerfs-sandbox/src/daemon/capacity.rs)) | +| `daemon_capacity` | record | the daemon's `backend.daemon.connection_failures` read model (#540): control admission by slot class and the bounded retained connection failures that used to hold a slot ([`control_capacity.rs`](../../../../../engine/crates/layerfs-bridge/src/control_capacity.rs)). It is read once, best effort, and only for a Sandbox that is `running` and whose machine and forward were reached; nothing is started and no second control slot is taken, so the field is simply absent when the daemon refuses, does not answer within 2 s, or was not asked ([`daemon/capacity.rs`](../../../../../control/crates/layerfs-sandbox/src/daemon/capacity.rs)) | ## Where it runs From 49e54038628f499108c33c8f2aeb9beeff9a5466 Mon Sep 17 00:00:00 2001 From: liuyuchen <152110621+jiangkoumo@users.noreply.github.com> Date: Wed, 11 Nov 2026 15:56:06 +0800 Subject: [PATCH 18/18] fix(sandbox): keep a fenced control connection out of the pool (#543) `capacity::lent` (the `sandbox.get` capacity read, #543) arms a fence on the pool connection it just borrowed, and `Lease::drop` decides reuse from `Control::is_failed()`. That answer was only `Control.failed`, which a fence's end never sets: `CloseHandle::close` (layerfs-bridge) sets the channel's own shared `failed` bit and shuts its socket down, and the `Control` above it learned of that only when a call it sent subsequently failed. The window, in order: 1. `trace::control_within` borrows a connection and `Fence::channel` arms it at the read's deadline. 2. `exchange` returns `Ok(answer)`: `Control.failed` is still false and the channel is healthy. 3. Before `drop(fence)` sends its stop, the fence thread's deadline expires and `CloseHandle::close()` quarantines the channel and shuts both directions down. `drop(fence)` joins that thread, so the close has completed before the lease is returned. 4. `Lease::drop` asks `Control::is_failed()`, hears false, and pushes the dead connection back into `pool.idle`. 5. The next call in the same long-lived process (a machine's worker, an SDK binding) pops it. `Sender::send` refuses at `shared.ready()` with `Quarantined` before writing a byte, but `Control::call_with` had already set `attempted = true`, so the caller is told `phase: Send, attempted: true` for an operation that never left. `capacity::lent` widened that window: its deadline was taken before `control_within(controls, WAIT)`, which re-reads the clock and may use the whole 2 s, so a read admitted at the boundary armed a fence already 0 ms from firing - a shutdown racing a reply that took microseconds. Fix, at the three points the ordering above crosses: - `layerfs-bridge`: `Connection::is_quarantined()` reads the one shared bit that every direction and close handle write. - `Control::is_failed()` is that bit or `Control.failed`, and `call_with` and `install_file` refuse on it before setting `attempted`. A quarantined connection now reports `phase: Encode, attempted: false` (nothing can have taken effect), and `Lease::drop` closes it instead of lending it again. - `capacity::lent` checks the window left after admission and refuses (`Unavailable`, nothing sent) instead of arming a spent deadline, which would shut a healthy connection down for nothing. Tests (`control/crates/layerfs-sandbox/tests/capacity_read.rs`): a fenced pool connection is not lent again (the next read opens the second connection and answers instead of reporting a quarantine), and a quarantined connection's call is `Encode` with `attempted: false`. With `is_failed` reverted to its previous form both fail; the first reproduces the reviewed symptom exactly (`phase: Send, attempted: true, cause: Channel(Quarantined)`). Docs: `docs/architecture/control/routing/daemon-channel.md` (the pool's drop line and the `Control` row) and `docs/architecture/api/sdk/sandbox/get.md` (what the fence and the spent admission window decide). Production LOC: 157130 -> 157143 (delta +13) Scope and method: first-party production Rust/SQL/JavaScript in core, engine, control and api (tests, fixtures, tools, docs, manifests and generated artifacts excluded), counted with `tools/production_loc.py` at the parent commit de009a8b8 and the committed tree. engine 73881 -> 73884 (+3, `duplex::Connection::is_quarantined`), control 38524 -> 38534 (+10, `daemon/capacity.rs` and `daemon/channel.rs`); core 39749 and api 4976 unchanged. Reference absent (retired R9c; last counted 65,417 at tree 498dd1917812). --- .../layerfs-sandbox/src/daemon/capacity.rs | 19 +++++- .../layerfs-sandbox/src/daemon/channel.rs | 16 +++-- .../layerfs-sandbox/src/daemon/fence.rs | 5 +- .../crates/layerfs-sandbox/src/daemon/pool.rs | 8 ++- .../layerfs-sandbox/tests/capacity_read.rs | 59 ++++++++++++++++++- docs/architecture/api/sdk/sandbox/get.md | 4 +- .../control/routing/daemon-channel.md | 6 +- .../layerfs-bridge/src/duplex/channel.rs | 7 +++ 8 files changed, 105 insertions(+), 19 deletions(-) diff --git a/control/crates/layerfs-sandbox/src/daemon/capacity.rs b/control/crates/layerfs-sandbox/src/daemon/capacity.rs index 4bf1a3f1a1..31b41b1556 100644 --- a/control/crates/layerfs-sandbox/src/daemon/capacity.rs +++ b/control/crates/layerfs-sandbox/src/daemon/capacity.rs @@ -46,12 +46,25 @@ pub fn read( /// The daemon's answer to [`OPERATION`] on a connection the Sandbox's pool /// lends (`sandbox.get`, #543): at most [`WAIT`] for admission and for the /// exchange, which is fenced at the same deadline, so this read takes no -/// second connection and no second slot of its own. Nothing is sent again, -/// and the connection goes back to the pool (or is closed, when the fence -/// quarantined it). +/// second connection and no second slot of its own. A window the admission +/// wait used up refuses the read before it is sent, and a connection the +/// fence ends stays quarantined: the pool closes it instead of lending it +/// again. Nothing is sent again. pub fn lent(controls: &Controls) -> Result { let deadline = Instant::now() + WAIT; let mut control = trace::control_within(controls, WAIT)?; + if deadline.saturating_duration_since(Instant::now()).is_zero() { + // the admission wait used the whole window. The connection is healthy + // and returns to the pool; arming a fence for a deadline that already + // passed would shut it down for nothing, so nothing is sent. + return Err(refused( + "Unavailable", + format!( + "no control connection came free within {}s, so the capacity read was not sent", + WAIT.as_secs() + ), + )); + } let fence = Fence::channel((control.close_handle().map_err(failed))?, deadline); let answer = exchange(&mut control); drop(fence); diff --git a/control/crates/layerfs-sandbox/src/daemon/channel.rs b/control/crates/layerfs-sandbox/src/daemon/channel.rs index eabe0636e3..49c161ef81 100644 --- a/control/crates/layerfs-sandbox/src/daemon/channel.rs +++ b/control/crates/layerfs-sandbox/src/daemon/channel.rs @@ -74,10 +74,13 @@ impl Control { pub fn take_telemetry(&mut self) -> Vec { std::mem::take(&mut self.telemetry) } - /// True once an exchange on this connection failed: it is quarantined, - /// and every later call on it is refused before sending. + /// True once this connection cannot carry another call: an exchange + /// failed on it, its session ended, or an application fence + /// ([`Control::close_handle`]) shut its channel down. The pool closes it + /// instead of lending it again, and a later call is refused before + /// sending, so a quarantined connection is never reported as an attempt. pub fn is_failed(&self) -> bool { - self.failed + self.failed || self.connection.is_quarantined() } /// Sends once and awaits the original reply once. Typed remote refusals are /// replies; failed delivery retains an unknown, never replays the command. @@ -118,7 +121,10 @@ impl Control { let mut attempted = false; let mut received = None; let result = (|| { - if self.failed { + if self.is_failed() { + // a fence or an ended session may have quarantined the channel + // after this owner's last call: nothing is sent on it + self.failed = true; return Err(ControlCause::Channel(ChannelError::Quarantined)); } let record = call.encode().map_err(ControlCause::Protocol)?; @@ -219,7 +225,7 @@ impl Control { manifest: &layerfs_bridge::provision::StoreManifest, ) -> Result> { - if self.failed { + if self.is_failed() { return Err(Box::new(layerfs_project::store::InstallFailure { source: store.path.clone(), manifest: manifest.clone(), diff --git a/control/crates/layerfs-sandbox/src/daemon/fence.rs b/control/crates/layerfs-sandbox/src/daemon/fence.rs index bfb2b9e735..fdbbf4345b 100644 --- a/control/crates/layerfs-sandbox/src/daemon/fence.rs +++ b/control/crates/layerfs-sandbox/src/daemon/fence.rs @@ -27,8 +27,9 @@ impl End { Self::Socket(socket) => { let _ = socket.shutdown(Shutdown::Both); } - // the handle quarantines the channel too, so the pool closes the - // connection instead of lending it again + // the handle quarantines the channel itself, and the pool reads + // that flag, so it closes the connection instead of lending it + // again Self::Channel(handle) => { let _ = handle.close(); } diff --git a/control/crates/layerfs-sandbox/src/daemon/pool.rs b/control/crates/layerfs-sandbox/src/daemon/pool.rs index 4588a3aff8..e7eab3a0be 100644 --- a/control/crates/layerfs-sandbox/src/daemon/pool.rs +++ b/control/crates/layerfs-sandbox/src/daemon/pool.rs @@ -5,8 +5,9 @@ //! every call wait for the one before it, a 1 ms read behind a whole Commit. A //! Sandbox keeps up to [`CONNECTIONS`] connections and opens one only when //! every open one is busy. Each exchange runs whole on one connection, sent -//! once. A connection whose exchange failed is quarantined by its `Control` -//! and is closed rather than reused; the failed call is never sent again. +//! once. A connection whose exchange failed, or whose channel an application +//! fence (`daemon::fence`) shut down, is quarantined by its `Control` and is +//! closed rather than reused; the failed call is never sent again. //! When the daemon admits no more connections, the Sandbox keeps the ones it //! has and callers take turns on them, each waiting at most [`LEND_WAIT`] //! before it is refused `Busy`. Opening a connection is not an attempt @@ -411,7 +412,8 @@ impl Drop for Lease<'_> { .lock() .unwrap_or_else(|poisoned| poisoned.into_inner()); if control.is_failed() { - // Quarantined: closed, and a later call may open another. + // Quarantined: its own failure or its channel's fence ended it, + // and a later call may open another. pool.open -= 1; drop(control); } else { diff --git a/control/crates/layerfs-sandbox/tests/capacity_read.rs b/control/crates/layerfs-sandbox/tests/capacity_read.rs index 9b5241fbfa..b90709a375 100644 --- a/control/crates/layerfs-sandbox/tests/capacity_read.rs +++ b/control/crates/layerfs-sandbox/tests/capacity_read.rs @@ -1,7 +1,8 @@ //! The `backend.daemon.connection_failures` read model's bounds (#540, //! #543): one query ends its control session instead of dropping the socket, -//! a daemon that trickles is fenced at the deadline, and a read on the -//! Sandbox's pool takes no second connection. +//! a daemon that trickles is fenced at the deadline, a read on the Sandbox's +//! pool takes no second connection, and a connection a fence or a session end +//! quarantined is never lent again or reported as an attempt. //! //! Nothing runs: a stand-in daemon answers the query on the connections it //! accepts, and counts what it saw. @@ -13,9 +14,12 @@ use layerfs_bridge::duplex; use layerfs_home::home::paths; use layerfs_home::secrets; use layerfs_sandbox::daemon::capacity; +use layerfs_sandbox::daemon::channel::ControlPhase; +use layerfs_sandbox::daemon::operator; use layerfs_sandbox::daemon::pool::{Controls, Dial}; use layerfs_sandbox::host::{Call as HostCall, Host, Message}; use layerfs_sandbox::record::SandboxRecord; +use layerfs_sandbox::{OperationCause, SdkError}; use std::io::Write; use std::net::{SocketAddr, TcpListener, TcpStream}; use std::os::unix::fs::PermissionsExt; @@ -298,3 +302,54 @@ fn the_worker_s_side_reads_the_capacity_model() { assert_eq!(seen.queries.load(Ordering::SeqCst), 1); std::fs::remove_dir_all(home).unwrap(); } + +#[test] +fn a_fenced_connection_is_not_lent_again() { + let (endpoint, seen) = daemon(Behavior::Model); + let dial = dial(endpoint); + let first = dial.open().unwrap(); + let controls = Controls::new(first, dial); + { + let lease = controls.lend().unwrap().0; + // the fence's end, outside any exchange: the channel is shut down + // while this `Control` never saw a call fail, which is the window + // between a returned reply and `drop(fence)` + lease.close_handle().unwrap().close().unwrap(); + assert!( + lease.is_failed(), + "a channel a fence closed was still reported healthy" + ); + } + // and the pool closed it rather than lending it again: the next read + // opens a connection and answers, instead of reporting the dead one + let answer = capacity::lent(&controls).unwrap(); + assert_eq!(CapacityModel::parse(&answer).admission.pool_vacant, 0); + assert_eq!(seen.connections.load(Ordering::SeqCst), 2); +} + +#[test] +fn a_quarantined_connection_attempts_nothing() { + let (endpoint, seen) = daemon(Behavior::Model); + let dial = dial(endpoint); + let first = dial.open().unwrap(); + let controls = Controls::new(first, dial); + let mut lease = controls.lend().unwrap().0; + lease.close_handle().unwrap().close().unwrap(); + // the call a pooled lease would make next: refused before sending, so it + // is not an attempt whose effect is unknown + let error = operator::call(&mut lease, CAPACITY_OPERATION, SdkValue::Null).unwrap_err(); + match error { + SdkError::Operation(failure) => match failure.cause { + OperationCause::Exchange(channel) => { + assert!( + !channel.attempted, + "a closed channel was reported attempted" + ); + assert_eq!(channel.phase, ControlPhase::Encode); + } + other => panic!("{other:?}"), + }, + other => panic!("{other:?}"), + } + assert_eq!(seen.queries.load(Ordering::SeqCst), 0); +} diff --git a/docs/architecture/api/sdk/sandbox/get.md b/docs/architecture/api/sdk/sandbox/get.md index 7986a6bd07..accb9c91d5 100644 --- a/docs/architecture/api/sdk/sandbox/get.md +++ b/docs/architecture/api/sdk/sandbox/get.md @@ -106,7 +106,9 @@ the Workspace list lent from the Sandbox's pool ([`daemon/pool.rs`](../../../../../control/crates/layerfs-sandbox/src/daemon/pool.rs)), bounded to 2 s for admission and for the exchange and fenced at that deadline ([`daemon/fence.rs`](../../../../../control/crates/layerfs-sandbox/src/daemon/fence.rs)), -so a daemon that trickles cannot hold the slot; a forwarded daemon's forward +so a daemon that trickles cannot hold the slot, and a connection the fence +ends is quarantined rather than lent again; a window the admission wait used +up refuses the read before it is sent. A forwarded daemon's forward and its machine are checked before it is dialed (`direct::check`), so a stopped machine is `down_reason` and never a 2 s wait on a reused port. See the [routing table](../../../control/routing/routing-table.md) and the diff --git a/docs/architecture/control/routing/daemon-channel.md b/docs/architecture/control/routing/daemon-channel.md index 7103015780..67bd11168d 100644 --- a/docs/architecture/control/routing/daemon-channel.md +++ b/docs/architecture/control/routing/daemon-channel.md @@ -33,7 +33,7 @@ side of the channel is in [Engine: Daemon](../../engine/daemon/README.md). | | | lend(): idle one --> else open one more (if open < limit) | | --> else wait for a free one, <= 60 s --> Busy | - | drop(Lease): failed Control --> closed, open -= 1 | + | drop(Lease): quarantined Control --> closed, open -= 1 | | healthy Control --> back to idle | +--------------------------------------------------------------+ | @@ -43,7 +43,7 @@ side of the channel is in [Engine: Daemon](../../engine/daemon/README.md). | Part | What it is | Source | | --- | --- | --- | -| `Control` | one sequential authenticated connection; numbers its calls; once an exchange fails it is quarantined and refuses every later call before sending | [`daemon/channel.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/channel.rs) | +| `Control` | one sequential authenticated connection; numbers its calls; once an exchange fails, or an applied fence (`close_handle`, `daemon/fence.rs`) closes its channel, it is quarantined and refuses every later call before sending | [`daemon/channel.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/channel.rs) | | `Dial` | how to open another connection to the same daemon instance: endpoint, secret, peer key, instance | [`daemon/pool.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/pool.rs) | | `Controls` | the Sandbox's pool: up to `CONNECTIONS` (6) per process; the daemon admits `DAEMON_CONNECTIONS` (8), leaving the rest to other processes | `daemon/pool.rs`, [`lifecycle.rs`](../../../../control/crates/layerfs-sandbox/src/lifecycle.rs) | | `Lease` | one connection lent for one call's exchanges, returned on drop | `daemon/pool.rs` | @@ -82,7 +82,7 @@ opening a connection sends only Hello, so it attempts no operation. | `workspace.commit` | `Commit` | `values::commit`: Committed, Merged (with `merged`), or `Conflict` | [`daemon/workspace/commit.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/workspace/commit.rs), [`daemon/values.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/values.rs) | | `workspace.unmount` | `Unmount{token, discard}`, or `ForceUnmount` with `force` | `values::unmounted` (`Dirty` refusal) or `force_unmounted` | [`daemon/workspace/unmount.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/workspace/unmount.rs) | | `workspace.status` | `Status(token)`; the Branch head is read separately on the Store's route | `values::status` | [`daemon/workspace/status.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/workspace/status.rs) | -| `sandbox.get` | SDK method `sandbox.list_workspaces`, then, on the same pooled connection and for a running Sandbox its machine still reaches, `backend.daemon.connection_failures` (`daemon_capacity`, bounded to 2 s: admission and the exchange share one deadline, fenced by [`daemon/fence.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/fence.rs)) | `sandbox/dispatch.rs` (both through `daemon/operator.rs`) | [`daemon/operator.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/operator.rs), [`daemon/capacity.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/capacity.rs) | +| `sandbox.get` | SDK method `sandbox.list_workspaces`, then, on the same pooled connection and for a running Sandbox its machine still reaches, `backend.daemon.connection_failures` (`daemon_capacity`, bounded to 2 s: admission and the exchange share one deadline, fenced by [`daemon/fence.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/fence.rs); a window admission used up refuses the read, and a connection the fence ends is not lent again) | `sandbox/dispatch.rs` (both through `daemon/operator.rs`) | [`daemon/operator.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/operator.rs), [`daemon/capacity.rs`](../../../../control/crates/layerfs-sandbox/src/daemon/capacity.rs) | | `workspace.exec` | none on this channel: `bash -c` runs through the Sandbox's runtime | — | [`exec/run.rs`](../../../../control/crates/layerfs-sandbox/src/exec/run.rs) | `Locate` and `Cleanup` are read-only observations for a caller whose diff --git a/engine/crates/layerfs-bridge/src/duplex/channel.rs b/engine/crates/layerfs-bridge/src/duplex/channel.rs index 0e56901692..76abb4c192 100644 --- a/engine/crates/layerfs-bridge/src/duplex/channel.rs +++ b/engine/crates/layerfs-bridge/src/duplex/channel.rs @@ -62,6 +62,13 @@ impl Connection { shared: self.receive.shared.clone(), }) } + /// Whether this channel is quarantined: a failed exchange, an ended + /// session or an application fence (`CloseHandle`) shut both directions + /// down, and no record may be sent on it again. All owners read the one + /// shared flag, so a fence's close is visible to whoever borrowed it. + pub fn is_quarantined(&self) -> bool { + self.receive.shared.ready().is_err() + } /// Clears explicit handshake I/O waits on the actual shared socket before long-lived operations. /// An original policy-change error quarantines/fences this owner once. pub fn clear_io_waits(&self) -> ChannelResult<()> {