368 lines
12 KiB
Rust
368 lines
12 KiB
Rust
#![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<Self> {
|
|
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<StreamHandle, bool>,
|
|
}
|
|
|
|
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<T>(
|
|
worker: &PulseWorker,
|
|
observations: &mut Observations,
|
|
fixture_name: &str,
|
|
mut select: impl FnMut(&WorkerEvent, &Observations) -> Option<T>,
|
|
) -> 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")
|
|
}
|
|
}
|
|
}
|
|
}
|