Reap stalled output on shutdown and allow orphan windows to close

This commit is contained in:
Dandaedre 2026-11-19 18:27:50 +01:00
parent 8a18759383
commit b2965f7207
10 changed files with 354 additions and 22 deletions

2
Cargo.lock generated
View File

@ -2212,7 +2212,7 @@ dependencies = [
[[package]]
name = "pdf-presenter"
version = "0.1.15"
version = "0.1.16"
dependencies = [
"bytemuck",
"chrono",

View File

@ -4,7 +4,7 @@ default-members = ["crates/pdf-presenter"]
resolver = "3"
[workspace.package]
version = "0.1.15"
version = "0.1.16"
edition = "2024"
license = "MIT"
repository = "https://proxy.dandaedre.com/gitea/idle-org/pdf-presenter"

View File

@ -265,6 +265,8 @@ fn monitors(el: &ActiveEventLoop) -> (Vec<(Monitor, MonitorHandle)>, usize) {
(handles, primary)
}
struct Host {
parent_connected: bool,
close_requested: bool,
commands: Receiver<HostState>,
acks: SyncSender<Ack>,
state: HostState,
@ -441,6 +443,7 @@ impl App {
{
if let Some(h) = &mut self.host {
h.state.blanked = true;
h.close_requested = matches!(key, Key::Named(NamedKey::Escape));
let _ = h.acks.try_send(Ack {
status: "Presentation blanked from output keyboard.".into(),
..Default::default()
@ -631,7 +634,18 @@ impl App {
);
}
if let Some(host) = &mut self.host {
while let Ok(state) = host.commands.try_recv() {
loop {
let state = match host.commands.try_recv() {
Ok(state) => state,
Err(mpsc::TryRecvError::Empty) => break,
Err(mpsc::TryRecvError::Disconnected) => {
host.parent_connected = false;
break;
}
};
if !state.blanked {
host.close_requested = false;
}
repaint = true;
if state.quit {
el.exit();
@ -667,6 +681,10 @@ impl App {
}
host.state = state;
}
if !host.parent_connected && (host.close_requested || self.windows.is_empty()) {
el.exit();
return;
}
while let Ok(c) = host.reader.rx.try_recv() {
repaint = true;
let reading = host.reading.take();
@ -797,6 +815,7 @@ impl ApplicationHandler for App {
s.execute(Action::CloseBrowser);
}
} else if let Some(h) = &mut self.host {
h.close_requested = true;
h.state.blanked = true;
let _ = h.acks.try_send(Ack {
status: "Presentation blanked from output window.".into(),
@ -954,10 +973,11 @@ pub fn run(options: crate::poc::Options, path: Option<std::path::PathBuf>) -> Re
override_presenter: options.presenter,
override_output: options.audience,
};
el.run_app(&mut app)?;
let result = el.run_app(&mut app);
if let Some(output) = &mut app.output {
output.shutdown();
}
result?;
if let Some(e) = app.error {
return Err(e.into());
}
@ -987,6 +1007,8 @@ pub fn run_output() -> Result<(), Failure> {
let mut app = App {
studio: None,
host: Some(Host {
parent_connected: true,
close_requested: false,
commands,
acks,
state: Default::default(),

View File

@ -6,9 +6,10 @@ use crate::{
use serde::{Deserialize, Serialize};
use std::{
io::Read,
process::Child,
path::PathBuf,
process::{Child, Command, Stdio},
sync::{
Arc,
Arc, Mutex,
atomic::{AtomicBool, Ordering},
mpsc::{self, Receiver, SyncSender},
},
@ -45,6 +46,7 @@ pub struct OutputLink {
pub rx: Receiver<Ack>,
stop: Arc<AtomicBool>,
manager: Option<std::thread::JoinHandle<()>>,
child: Arc<Mutex<Option<Child>>>,
}
impl Default for OutputLink {
fn default() -> Self {
@ -53,26 +55,39 @@ impl Default for OutputLink {
}
impl OutputLink {
pub fn new() -> Self {
Self::with_program(std::env::current_exe().unwrap_or_default())
}
pub fn with_program(program: PathBuf) -> Self {
let (tx, commands) = mpsc::sync_channel::<HostState>(2);
let (results, rx) = mpsc::sync_channel(8);
let stop = Arc::new(AtomicBool::new(false));
let end = stop.clone();
let child = Arc::new(Mutex::new(None));
let managed_child = child.clone();
let manager = std::thread::spawn(move || {
let mut attempts = 0;
while !end.load(Ordering::Relaxed) && attempts < 3 {
attempts += 1;
let mut child = match spawn_mode("--presentation-host") {
let mut command = Command::new(&program);
command
.arg("--presentation-host")
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::null());
crate::worker::quiet_child(&mut command);
let mut process = match command.spawn() {
Ok(c) => c,
Err(e) => {
let _ = results.try_send(Ack {
status: e,
status: e.to_string(),
..Default::default()
});
return;
}
};
let mut stdin = child.stdin.take().unwrap();
let mut stdout = child.stdout.take().unwrap();
let mut stdin = process.stdin.take().unwrap();
let mut stdout = process.stdout.take().unwrap();
*managed_child.lock().unwrap() = Some(process);
let (ack_tx, ack_rx) = mpsc::sync_channel(8);
std::thread::spawn(move || {
while let Ok(ack) = read_json::<Ack>(&mut stdout) {
@ -91,8 +106,7 @@ impl OutputLink {
},
);
std::thread::sleep(Duration::from_millis(300));
let _ = child.kill();
let _ = child.wait();
terminate_output(&managed_child);
return;
}
let mut latest = None;
@ -109,15 +123,18 @@ impl OutputLink {
heartbeat = Instant::now();
let _ = results.try_send(ack);
}
if child.try_wait().ok().flatten().is_some()
if managed_child
.lock()
.unwrap()
.as_mut()
.is_none_or(|c| c.try_wait().ok().flatten().is_some())
|| heartbeat.elapsed() > Duration::from_secs(8)
{
break;
}
std::thread::sleep(Duration::from_millis(4));
}
let _ = child.kill();
let _ = child.wait();
terminate_output(&managed_child);
let _=results.try_send(Ack{status:"Presentation host stopped. Output will restart blanked; review screens before resuming.".into(),..Default::default()});
// Restart receives a fresh state from the presenter; never silently resume output.
drop(last);
@ -129,6 +146,7 @@ impl OutputLink {
rx,
stop,
manager: Some(manager),
child,
}
}
}
@ -136,7 +154,13 @@ impl OutputLink {
/// Called after the event loop exits, never from an input/render callback.
pub fn shutdown(&mut self) {
self.stop.store(true, Ordering::Relaxed);
let deadline = Instant::now() + Duration::from_secs(2);
let grace = Instant::now() + Duration::from_millis(500);
while self.manager.as_ref().is_some_and(|t| !t.is_finished()) && Instant::now() < grace {
std::thread::sleep(Duration::from_millis(10));
}
// This does not use the IPC writer: it also works when that writer is blocked.
terminate_output(&self.child);
let deadline = Instant::now() + Duration::from_secs(1);
while self.manager.as_ref().is_some_and(|t| !t.is_finished()) && Instant::now() < deadline {
std::thread::sleep(Duration::from_millis(10));
}
@ -147,11 +171,18 @@ impl OutputLink {
}
}
}
impl Drop for OutputLink {
fn drop(&mut self) {
self.stop.store(true, Ordering::Relaxed);
fn terminate_output(child: &Mutex<Option<Child>>) {
if let Some(mut process) = child.lock().unwrap().take() {
let _ = process.kill();
let _ = process.wait();
}
}
impl Drop for OutputLink {
fn drop(&mut self) {
self.shutdown();
}
}
pub struct SleepLease {
child: Option<Child>,
pub status: Receiver<String>,
@ -271,3 +302,47 @@ fn hold_x11_fallback(_lease: Option<X11Lease>, status: String) -> Result<(), Str
let _ = std::io::stdin().read(&mut [0]);
Ok(())
}
#[cfg(all(test, unix))]
mod shutdown_tests {
use super::*;
use std::os::unix::fs::PermissionsExt;
#[test]
fn shutdown_and_drop_reap_output_even_when_its_input_pipe_is_full() {
let temp = tempfile::tempdir().unwrap();
let program = temp.path().join("unresponsive-output");
std::fs::write(&program, "#!/bin/sh\nexec sleep 60\n").unwrap();
std::fs::set_permissions(&program, std::fs::Permissions::from_mode(0o700)).unwrap();
for explicit in [true, false] {
let mut link = OutputLink::with_program(program.clone());
let child = link.child.clone();
let deadline = Instant::now() + Duration::from_secs(5);
let pid = loop {
if let Some(process) = child.lock().unwrap().as_ref() {
break process.id();
}
assert!(Instant::now() < deadline, "output did not spawn");
std::thread::sleep(Duration::from_millis(10));
};
link.tx
.send(HostState {
monitors: vec!["x".repeat(2 * 1024 * 1024)],
..Default::default()
})
.unwrap();
// The child never reads stdin: this message is larger than the pipe capacity.
std::thread::sleep(Duration::from_millis(100));
let start = Instant::now();
if explicit {
link.shutdown();
assert!(link.manager.is_none());
}
drop(link);
assert!(start.elapsed() < Duration::from_secs(2));
assert!(child.lock().unwrap().is_none());
// The PID is only used immediately after reaping our own child.
assert_eq!(unsafe { libc::kill(pid as i32, 0) }, -1);
}
}
}

View File

@ -229,7 +229,7 @@ pub fn run() -> Result<(), String> {
}
Ok(())
}
fn quiet_child(command: &mut Command) {
pub(crate) fn quiet_child(command: &mut Command) {
#[cfg(target_os = "windows")]
{
use std::os::windows::process::CommandExt;

View File

@ -210,3 +210,183 @@ fn independent_output_acknowledges_frames_and_blanking() {
}
assert!(child.0.try_wait().unwrap().is_some(), "host did not exit");
}
#[cfg(target_os = "linux")]
#[test]
fn orphaned_output_holds_until_closed_then_exits_on_close_or_escape() {
if std::env::var_os("PDF_PRESENTER_GUI_TESTS").is_none() {
return;
}
use pdf_presenter::{output::HostState, worker::write_json};
use x11_dl::xlib;
let x = xlib::Xlib::open().unwrap();
// A private X11 connection is used only by this test thread.
let display = unsafe { (x.XOpenDisplay)(std::ptr::null()) };
assert!(!display.is_null());
struct DisplayGuard<'a>(&'a xlib::Xlib, *mut xlib::Display);
impl Drop for DisplayGuard<'_> {
fn drop(&mut self) {
unsafe {
(self.0.XCloseDisplay)(self.1);
}
}
}
let _display = DisplayGuard(&x, display);
let root = unsafe { (x.XDefaultRootWindow)(display) };
let pid_atom = unsafe { (x.XInternAtom)(display, c"_NET_WM_PID".as_ptr(), 0) };
fn find(
x: &xlib::Xlib,
d: *mut xlib::Display,
w: xlib::Window,
atom: xlib::Atom,
pid: u32,
) -> Option<xlib::Window> {
// Xlib owns returned buffers; free them after copying their contents.
unsafe {
let (mut kind, mut format, mut n, mut after) = (0, 0, 0, 0);
let mut data = std::ptr::null_mut();
(x.XGetWindowProperty)(
d,
w,
atom,
0,
1,
0,
xlib::XA_CARDINAL,
&mut kind,
&mut format,
&mut n,
&mut after,
&mut data,
);
let matches = !data.is_null()
&& format == 32
&& n == 1
&& *(data as *const std::os::raw::c_ulong) == u64::from(pid);
if !data.is_null() {
(x.XFree)(data.cast());
}
if matches {
return Some(w);
}
let (mut root, mut parent, mut count) = (0, 0, 0);
let mut children = std::ptr::null_mut();
if (x.XQueryTree)(d, w, &mut root, &mut parent, &mut children, &mut count) == 0 {
return None;
}
let found = if children.is_null() {
None
} else {
std::slice::from_raw_parts(children, count as usize)
.iter()
.find_map(|child| find(x, d, *child, atom, pid))
};
if !children.is_null() {
(x.XFree)(children.cast());
}
found
}
}
let listing = run_native(&["--list-monitors"]);
let listing = String::from_utf8(listing.stdout).unwrap();
let line = listing
.lines()
.find(|l| l.starts_with("Display 1:"))
.unwrap();
let name = line
.split(" at ")
.next()
.unwrap()
.rsplit_once(' ')
.unwrap()
.0
.split_once(": ")
.unwrap()
.1;
for escape in [false, true] {
struct ChildGuard(std::process::Child);
impl Drop for ChildGuard {
fn drop(&mut self) {
let _ = self.0.kill();
let _ = self.0.wait();
}
}
let mut child = ChildGuard(
Command::new(env!("CARGO_BIN_EXE_pdf-presenter"))
.env("WINIT_UNIX_BACKEND", "x11")
.arg("--presentation-host")
.stdin(Stdio::piped())
.stdout(Stdio::null())
.spawn()
.unwrap(),
);
let mut input = child.0.stdin.take().unwrap();
write_json(
&mut input,
&HostState {
monitors: vec![format!("{name}#1")],
fullscreen: false,
..Default::default()
},
)
.unwrap();
let deadline = Instant::now() + Duration::from_secs(5);
let window = loop {
if let Some(window) = find(&x, display, root, pid_atom, child.0.id()) {
break window;
}
assert!(Instant::now() < deadline, "output window not created");
std::thread::sleep(Duration::from_millis(10));
};
// EOF models a vanished presenter. Keep the output alive until the operator closes it.
drop(input);
std::thread::sleep(Duration::from_millis(300));
assert!(child.0.try_wait().unwrap().is_none());
unsafe {
let mut event: xlib::XEvent = std::mem::zeroed();
if escape {
event.key = xlib::XKeyEvent {
type_: xlib::KeyPress,
display,
window,
root,
keycode: (x.XKeysymToKeycode)(display, 0xff1b).into(),
same_screen: 1,
..std::mem::zeroed()
};
} else {
let mut data = xlib::ClientMessageData::new();
data.set_long(
0,
(x.XInternAtom)(display, c"WM_DELETE_WINDOW".as_ptr(), 0) as _,
);
event.client_message = xlib::XClientMessageEvent {
type_: xlib::ClientMessage,
display,
window,
message_type: (x.XInternAtom)(display, c"WM_PROTOCOLS".as_ptr(), 0),
format: 32,
data,
..std::mem::zeroed()
};
}
(x.XSendEvent)(
display,
window,
0,
if escape { xlib::KeyPressMask } else { 0 },
&mut event,
);
(x.XFlush)(display);
}
let deadline = Instant::now() + Duration::from_secs(3);
while child.0.try_wait().unwrap().is_none() && Instant::now() < deadline {
std::thread::sleep(Duration::from_millis(10));
}
assert!(
child.0.try_wait().unwrap().is_some(),
"orphan ignored {}",
if escape { "Escape" } else { "Close" }
);
}
}

View File

@ -2,6 +2,17 @@
## Unreleased
### 0.1.16
- Ensure presenter shutdown can terminate/reap its output process even when the
supervisor is blocked writing to a full IPC pipe. Run cleanup on event-loop errors
and destructor paths as well as normal exit.
- Detect loss of the presenter connection. Preserve the last audience frame, but
allow the orphaned output to exit through its window Close control or Escape.
- Add blocked-pipe shutdown/drop regression coverage and native Linux/X11 orphan
Close/Escape tests. Windows/macOS runtime acceptance remains pending.
### 0.1.15
- Give Windows PDF/folder dialogs the active presenter window as their owner, so

View File

@ -169,3 +169,25 @@ compile-check pass; Windows fullscreen/modal placement requires user runtime ret
Formatting and warnings-denied Clippy/rustdoc pass. Whole-app coverage is 82.88% with
no production exclusions. An initial coverage run failed to merge a corrupted worker
profile; a fresh full run passed. Linux release is rebuilt for the shared admission fix.
## 0.1.16 output lifecycle correction
The output Close handler previously only blanked, even after the presenter pipe
closed. The native host now observes receiver disconnection and accepts Close/Escape
as exit when orphaned, while retaining crash-time last-frame preservation until then.
Normal presenter exit, event-loop errors and OutputLink destruction all shut down the
owned host. A separate shared process handle permits termination/reaping even when
the supervisor is blocked writing a large state into an unread pipe.
Regression tests fill a fake output's pipe and verify both shutdown and Drop reap it
within two seconds. Native Linux/X11 tests create real output windows, disconnect
the parent pipe, verify the process remains alive, then send WM_DELETE_WINDOW or
Escape and verify clean exit without force-kill. Test guards kill only on failure or
cleanup. These checks do not establish Windows/macOS physical acceptance.
46 Rust tests and 10 Python tests pass, including the native window/output tests.
Formatting, warnings-denied Clippy/rustdoc and macOS aarch64 compilation pass.
Whole-application coverage is 83.97%, with no production exclusions. Linux and Windows
x86_64 release builds succeed. Runtime retesting on Windows remains necessary for
the reported platform behavior.

View File

@ -60,3 +60,22 @@ the guard; submission failure never sets it. The native host re-enables presente
input and restores owner focus after completion, including a worker killed while the
common dialog had disabled its owner. Existing slide-browser windows temporarily
lose topmost status while the chooser is active. Rendering/output stay independent.
## Output shutdown and lost presenter, 0.1.16
No wire fields change. EOF/failed input drops the host command sender; the native
host detects receiver disconnection instead of treating it as an empty queue forever.
An established output keeps its last frame after unexpected connection loss, while
Close or Escape requests exit on the next event-loop tick. A disconnected host with
no windows exits immediately. B still blanks. With a live presenter, output Close or
Escape retains the existing emergency-blank behavior.
Normal presenter shutdown signals the supervisor and allows 500 ms for graceful
completion, then terminates/reaps the owned child through a separate shared process
handle. The handle is never locked during pipe writes, so a blocked writer cannot
prevent termination. A further one-second manager completion wait is bounded.
Event-loop errors and OutputLink destruction use this cleanup path as well. OS process
termination/reaping still relies on OS responsiveness; these bounds are not a promise
against kernel/driver failure. Unexpected presenter death deliberately does not use
parent-death termination for the audience, to preserve the last usable frame.

View File

@ -30,7 +30,7 @@ usable frame. The footer distinguishes requested and acknowledged displayed slid
**NO OUTPUT DISPLAYED** warning marks blanking, no assigned output or no document;
it remains visible when the footer is hidden. Preparing output has a separate status.
Escape cancels a pending slide number/menu, closes the browser, or safely leaves
fullscreen and blanks output. Closing a presentation window blanks it; close a
fullscreen and blanks output. While the presenter is connected, closing a presentation window blanks it; close a
presenter or choose Menu → Quit to end the application.
Arrow keys, Page Up/Down and Space navigate from the presenter. Type a 1-based slide
@ -117,7 +117,10 @@ Rendering, notes, file dialogs and settings I/O run in supervised child processe
the same executable. A stuck renderer is terminated after its deadline; the UI and
last output remain available. Reopen the source to retry failed pages. A presentation
host failure restarts blanked with a status message, up to three starts. If the
presenter crashes, the output process holds its last frame; B/Escape can blank it.
presenter crashes, the output process holds its last frame. B can blank it; Escape or
its normal window Close control exits the disconnected output. Closing the presenter
normally shuts down the output process too, with a separate termination fallback if
its IPC writer is stuck.
Automatic reconnection to that orphaned show is not implemented yet.
Sleep protection is requested for both native processes, including while blanked.