diff --git a/sound/src/pulse.rs b/sound/src/pulse.rs index fb82138..6f15bdc 100644 --- a/sound/src/pulse.rs +++ b/sound/src/pulse.rs @@ -140,6 +140,12 @@ impl PulseClient { }; let deadline = Instant::now() + timeout; while notifications.borrow().is_empty() { + match self.context.get_state() { + State::Failed | State::Terminated => { + return Err(PulseError::ContextState(self.context.get_state())); + } + _ => {} + } if Instant::now() >= deadline { return Ok(None); } diff --git a/sound/tests/pulse_daemon.rs b/sound/tests/pulse_daemon.rs new file mode 100644 index 0000000..1a99a96 --- /dev/null +++ b/sound/tests/pulse_daemon.rs @@ -0,0 +1,367 @@ +#![cfg(feature = "pulse")] + +use std::{ + collections::BTreeMap, + io, + process::{Child, Command, Stdio}, + sync::mpsc::RecvTimeoutError, + thread, + time::{Duration, Instant}, +}; + +use fader_core::{ + AdapterCommand, AdapterEvent, BackendEpoch, ChannelGains, Gain, MetadataField, Mute, + OperationId, StreamHandle, +}; +use volume_lib::{PulseClient, PulseWorker, RetrySchedule, WorkerEvent}; + +const EVENT_TIMEOUT: Duration = Duration::from_secs(8); +const FIXTURE_GAIN_TOLERANCE: f64 = 0.001; + +struct SilentPlayback { + child: Child, +} + +impl SilentPlayback { + fn spawn(name: &str) -> io::Result { + let child = Command::new("paplay") + .args([ + "--raw", + "--rate=48000", + "--format=s16le", + "--channels=2", + &format!("--client-name={name}"), + &format!("--stream-name={name}"), + &format!("--property=application.name={name}"), + "/dev/zero", + ]) + .stdin(Stdio::null()) + .stdout(Stdio::null()) + .stderr(Stdio::null()) + .spawn()?; + Ok(Self { child }) + } +} + +impl Drop for SilentPlayback { + fn drop(&mut self) { + let _ = self.child.kill(); + let _ = self.child.wait(); + } +} + +#[derive(Default)] +struct Observations { + matching: BTreeMap, +} + +impl Observations { + fn record_metadata( + &mut self, + stream: StreamHandle, + metadata: &fader_core::StreamMetadata, + fixture_name: &str, + ) { + self.matching.insert( + stream, + metadata.value(MetadataField::ApplicationName) == Some(fixture_name), + ); + } + + fn is_fixture(&self, stream: StreamHandle) -> bool { + self.matching.get(&stream).copied().unwrap_or(false) + } +} + +fn receive_until( + worker: &PulseWorker, + observations: &mut Observations, + fixture_name: &str, + mut select: impl FnMut(&WorkerEvent, &Observations) -> Option, +) -> T { + let deadline = Instant::now() + EVENT_TIMEOUT; + loop { + let remaining = deadline + .checked_duration_since(Instant::now()) + .expect("timed out waiting for Pulse fixture event"); + let event = worker + .receive_timeout(remaining) + .expect("Pulse worker disconnected before the expected fixture event"); + println!("fixture event: {event:?}"); + if let WorkerEvent::StreamMetadata { + stream, metadata, .. + } = &event + { + observations.record_metadata(*stream, metadata, fixture_name); + } + if let WorkerEvent::Disconnected { message, .. } = &event { + panic!("Pulse worker disconnected during fixture: {message}"); + } + if let Some(value) = select(&event, observations) { + return value; + } + } +} + +fn wait_for_fixture_stream( + worker: &PulseWorker, + observations: &mut Observations, + fixture_name: &str, +) -> (StreamHandle, ChannelGains, Mute) { + receive_until( + worker, + observations, + fixture_name, + |event, observations| match event { + WorkerEvent::Adapter(AdapterEvent::Observed { + stream, + channels, + muted, + .. + }) if observations.is_fixture(*stream) => Some((*stream, channels.clone(), *muted)), + _ => None, + }, + ) +} + +fn wait_for_operation( + worker: &PulseWorker, + observations: &mut Observations, + fixture_name: &str, + expected: OperationId, +) -> (ChannelGains, Mute) { + receive_until(worker, observations, fixture_name, |event, _| match event { + WorkerEvent::Adapter(AdapterEvent::Observed { + channels, + muted, + operation: Some(operation), + .. + }) if *operation == expected => Some((channels.clone(), *muted)), + _ => None, + }) +} + +fn wait_for_external_state( + worker: &PulseWorker, + observations: &mut Observations, + fixture_name: &str, + handle: StreamHandle, + gain: Gain, + muted: Mute, +) { + receive_until(worker, observations, fixture_name, |event, _| match event { + WorkerEvent::Adapter(AdapterEvent::Observed { + stream, + channels, + muted: actual_mute, + operation: None, + }) if *stream == handle + && *actual_mute == muted + && (channels.maximum().get() - gain.get()).abs() <= FIXTURE_GAIN_TOLERANCE => + { + Some(()) + } + _ => None, + }); +} + +fn equal_channels(count: usize, gain: Gain) -> ChannelGains { + ChannelGains::new(vec![gain; count]).expect("fixture stream has at least one channel") +} + +/// Opt-in: creates and controls only a uniquely named silent playback stream. +#[test] +#[ignore = "requires a live PulseAudio-compatible daemon and paplay"] +fn real_stream_commands_external_edits_and_churn_converge() { + let fixture_name = format!("fader-master-fixture-{}", std::process::id()); + let mut playback = SilentPlayback::spawn(&fixture_name).expect("spawn silent paplay fixture"); + let mut worker = PulseWorker::spawn(BackendEpoch::new(1), 512); + let mut observations = Observations::default(); + let (handle, initial_channels, _) = + wait_for_fixture_stream(&worker, &mut observations, &fixture_name); + + let worker_gain = Gain::new(0.35).unwrap(); + worker + .try_submit(AdapterCommand::SetVolume { + operation: OperationId::new(1), + stream: handle, + channels: equal_channels(initial_channels.as_slice().len(), worker_gain), + }) + .expect("queue fixture worker volume"); + let (channels, _) = wait_for_operation( + &worker, + &mut observations, + &fixture_name, + OperationId::new(1), + ); + assert!((channels.maximum().get() - worker_gain.get()).abs() <= FIXTURE_GAIN_TOLERANCE); + + worker + .try_submit(AdapterCommand::SetMute { + operation: OperationId::new(2), + stream: handle, + muted: Mute::Muted, + }) + .expect("queue fixture worker mute"); + let (_, muted) = wait_for_operation( + &worker, + &mut observations, + &fixture_name, + OperationId::new(2), + ); + assert_eq!(muted, Mute::Muted); + + let mut external = PulseClient::connect().expect("connect independent external client"); + let index = u32::try_from(handle.backend_id()).expect("Pulse index fits u32"); + let external_gain = Gain::new(0.65).unwrap(); + let current = external + .stream(index) + .expect("read fixture from external client"); + external + .set_volume( + index, + &equal_channels(current.channels.as_slice().len(), external_gain), + ) + .expect("external fixture volume write"); + external + .set_mute(index, Mute::Unmuted) + .expect("external fixture unmute"); + wait_for_external_state( + &worker, + &mut observations, + &fixture_name, + handle, + external_gain, + Mute::Unmuted, + ); + + drop(playback); + receive_until( + &worker, + &mut observations, + &fixture_name, + |event, _| match event { + WorkerEvent::Adapter(AdapterEvent::StreamRemoved { stream }) if *stream == handle => { + Some(()) + } + _ => None, + }, + ); + playback = SilentPlayback::spawn(&fixture_name).expect("respawn silent paplay fixture"); + let (replacement, _, _) = wait_for_fixture_stream(&worker, &mut observations, &fixture_name); + assert_ne!(replacement, handle); + + drop(playback); + assert!(worker.shutdown()); + assert!(!worker.event_overflowed()); +} + +/// Opt-in and disruptive: restarts the current user's PipeWire audio services. +#[test] +#[ignore = "set FADER_MASTER_RESTART_PIPEWIRE=1; interrupts desktop audio"] +fn pipewire_restart_disconnects_and_a_new_epoch_resnapshots() { + assert_eq!( + std::env::var("FADER_MASTER_RESTART_PIPEWIRE").as_deref(), + Ok("1"), + "set FADER_MASTER_RESTART_PIPEWIRE=1 to acknowledge desktop audio interruption" + ); + + let mut worker = PulseWorker::spawn(BackendEpoch::new(20), 512); + wait_for_snapshot(&worker); + let status = Command::new("systemctl") + .args([ + "--user", + "restart", + "pipewire.service", + "pipewire-pulse.service", + "wireplumber.service", + ]) + .status() + .expect("run systemctl user restart"); + assert!(status.success(), "PipeWire user-service restart failed"); + wait_for_disconnect(&worker); + assert!(worker.shutdown()); + + let mut retries = RetrySchedule::new(100, 1_000); + let deadline = Instant::now() + Duration::from_secs(10); + let mut epoch = BackendEpoch::new(21); + loop { + thread::sleep(Duration::from_millis(retries.next_delay_ms())); + let mut replacement = PulseWorker::spawn(epoch, 512); + match wait_for_ready_or_disconnect(&replacement) { + true => { + wait_for_snapshot_end(&replacement); + assert!(replacement.shutdown()); + break; + } + false => { + assert!(replacement.shutdown()); + assert!( + Instant::now() < deadline, + "PipeWire did not recover in time" + ); + epoch = epoch.checked_next().expect("fixture epoch space"); + } + } + } +} + +fn wait_for_snapshot(worker: &PulseWorker) { + assert!(wait_for_ready_or_disconnect(worker)); + wait_for_snapshot_end(worker); +} + +fn wait_for_ready_or_disconnect(worker: &PulseWorker) -> bool { + let deadline = Instant::now() + EVENT_TIMEOUT; + loop { + let remaining = deadline + .checked_duration_since(Instant::now()) + .expect("timed out waiting for Pulse readiness"); + match worker.receive_timeout(remaining) { + Ok(WorkerEvent::Ready { .. }) => return true, + Ok(WorkerEvent::Disconnected { message, .. }) => { + println!("fixture reconnect attempt failed: {message}"); + return false; + } + Ok(event) => println!("fixture readiness event: {event:?}"), + Err(error) => panic!("Pulse readiness channel failed: {error}"), + } + } +} + +fn wait_for_snapshot_end(worker: &PulseWorker) { + let deadline = Instant::now() + EVENT_TIMEOUT; + loop { + let remaining = deadline + .checked_duration_since(Instant::now()) + .expect("timed out waiting for Pulse snapshot end"); + match worker.receive_timeout(remaining) { + Ok(WorkerEvent::SnapshotEnd(_)) => return, + Ok(WorkerEvent::Disconnected { message, .. }) => { + panic!("Pulse disconnected during snapshot: {message}"); + } + Ok(event) => println!("fixture snapshot event: {event:?}"), + Err(error) => panic!("Pulse snapshot channel failed: {error}"), + } + } +} + +fn wait_for_disconnect(worker: &PulseWorker) { + let deadline = Instant::now() + EVENT_TIMEOUT; + loop { + let remaining = deadline + .checked_duration_since(Instant::now()) + .expect("timed out waiting for daemon disconnect"); + match worker.receive_timeout(remaining) { + Ok(WorkerEvent::Disconnected { message, .. }) => { + println!("fixture observed expected disconnect: {message}"); + return; + } + Ok(event) => println!("fixture pre-disconnect event: {event:?}"), + Err(RecvTimeoutError::Timeout) => panic!("daemon restart produced no disconnect"), + Err(RecvTimeoutError::Disconnected) => { + panic!("worker exited without a Disconnected diagnostic") + } + } + } +}