From a01e4516436605ca4e28d4d6894983d077958d75 Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Thu, 15 Oct 2026 00:12:08 +0200 Subject: [PATCH] feat(M7.3): publish revisioned live mixer state Translate copied worker metadata and observations into labeled snapshots, preserve pending writes until correlated readback, and reject stale client revisions. Tests: cargo test -p fader_master --test live_mixer --all-features Tests: cargo clippy -p fader_master --all-targets --all-features --locked -- -D warnings --- fader_master/src/lib.rs | 1 + fader_master/src/live.rs | 204 +++++++++++++++++++++++++++++++ fader_master/tests/live_mixer.rs | 108 ++++++++++++++++ 3 files changed, 313 insertions(+) create mode 100644 fader_master/src/live.rs create mode 100644 fader_master/tests/live_mixer.rs diff --git a/fader_master/src/lib.rs b/fader_master/src/lib.rs index 8ce2b94..f694ec5 100644 --- a/fader_master/src/lib.rs +++ b/fader_master/src/lib.rs @@ -4,6 +4,7 @@ pub mod cli; pub mod ipc; +pub mod live; use std::{collections::BTreeMap, error::Error, fmt}; diff --git a/fader_master/src/live.rs b/fader_master/src/live.rs new file mode 100644 index 0000000..717270e --- /dev/null +++ b/fader_master/src/live.rs @@ -0,0 +1,204 @@ +use std::collections::BTreeMap; + +use fader_core::{ + AdapterCommand, AdapterEvent, CommandOrigin, Gain, MetadataField, Mute, Revision, + ServerCommand, ServerReducer, StreamHandle, StreamMetadata, +}; +use thiserror::Error; +use volume_lib::WorkerEvent; + +use crate::ipc::{ + ClientRequest, MixerSnapshot, MixerStream, PROTOCOL_VERSION, RequestCommand, ResponseResult, + ServerResponse, StreamKey, +}; + +#[derive(Clone, Debug)] +struct MetadataView { + metadata: StreamMetadata, + writable: bool, +} + +/// Pure live-mixer state between the Pulse worker and IPC clients. +#[derive(Debug)] +pub struct LiveMixerState { + reducer: ServerReducer, + metadata: BTreeMap, + backend: String, + status: String, +} + +#[derive(Debug, Error)] +pub enum LiveMixerError { + #[error(transparent)] + Reducer(#[from] fader_core::ReducerError), + #[error(transparent)] + Gain(#[from] fader_core::GainError), + #[error("unsupported IPC protocol version {actual}; expected {expected}")] + Protocol { actual: u16, expected: u16 }, +} + +impl LiveMixerState { + #[must_use] + pub fn new(write_ceiling: Gain, backend: impl Into) -> Self { + Self { + reducer: ServerReducer::new(write_ceiling), + metadata: BTreeMap::new(), + backend: backend.into(), + status: "connecting".to_owned(), + } + } + + /// Applies one copied adapter event and returns any follow-up commands. + pub fn worker_event( + &mut self, + event: WorkerEvent, + ) -> Result, LiveMixerError> { + match event { + WorkerEvent::Ready { .. } => self.status = "syncing".to_owned(), + WorkerEvent::SnapshotBegin(_) => self.status = "syncing".to_owned(), + WorkerEvent::SnapshotEnd(_) => self.status = "ready".to_owned(), + WorkerEvent::StreamMetadata { + stream, + metadata, + volume_writable, + } => { + self.metadata.insert( + stream, + MetadataView { + metadata, + writable: volume_writable, + }, + ); + } + WorkerEvent::Adapter(event) => { + if let AdapterEvent::StreamRemoved { stream } = &event { + self.metadata.remove(stream); + } + return Ok(self.reducer.event(event)?.adapter); + } + WorkerEvent::Disconnected { message, .. } => { + self.status = format!("unavailable: {message}"); + } + } + Ok(Vec::new()) + } + + #[must_use] + pub fn snapshot(&self) -> MixerSnapshot { + let streams = self + .metadata + .iter() + .filter_map(|(handle, metadata)| { + let view = self.reducer.view(*handle)?; + Some(MixerStream { + stream: key(*handle), + label: stream_label(&metadata.metadata, *handle), + process: metadata + .metadata + .value(MetadataField::ProcessBinary) + .map(str::to_owned), + gain: view.channels.maximum().get(), + muted: view.muted == Mute::Muted, + pending: view.pending, + writable: metadata.writable, + error: view.error, + }) + }) + .collect(); + MixerSnapshot { + revision: self.reducer.revision().get(), + backend: self.backend.clone(), + status: self.status.clone(), + streams, + } + } + + pub fn request( + &mut self, + request: ClientRequest, + ) -> Result<(ServerResponse, Vec), LiveMixerError> { + if request.version != PROTOCOL_VERSION { + return Err(LiveMixerError::Protocol { + actual: request.version, + expected: PROTOCOL_VERSION, + }); + } + let commands = match request.command { + RequestCommand::Snapshot => Vec::new(), + RequestCommand::SetVolume { + stream, + gain, + expected_revision, + } => { + self.reducer + .command(ServerCommand::SetVolume { + origin: CommandOrigin::Client { + request: request.request_id, + }, + expected_revision: Revision::new(expected_revision), + stream: handle(stream), + target: Gain::new(gain)?, + })? + .adapter + } + RequestCommand::ToggleMute { + stream, + expected_revision, + } => { + let stream = handle(stream); + let current = self + .reducer + .view(stream) + .ok_or(fader_core::ReducerError::Offline(stream))?; + self.reducer + .command(ServerCommand::SetMute { + origin: CommandOrigin::Client { + request: request.request_id, + }, + expected_revision: Revision::new(expected_revision), + stream, + muted: if current.muted == Mute::Muted { + Mute::Unmuted + } else { + Mute::Muted + }, + })? + .adapter + } + }; + Ok(( + ServerResponse { + version: PROTOCOL_VERSION, + request_id: request.request_id, + result: ResponseResult::Snapshot { + snapshot: self.snapshot(), + }, + }, + commands, + )) + } +} + +fn key(handle: StreamHandle) -> StreamKey { + StreamKey { + epoch: handle.epoch().get(), + backend_id: handle.backend_id(), + incarnation: handle.incarnation(), + } +} + +fn handle(key: StreamKey) -> StreamHandle { + StreamHandle::new( + fader_core::BackendEpoch::new(key.epoch), + key.backend_id, + key.incarnation, + ) +} + +fn stream_label(metadata: &StreamMetadata, handle: StreamHandle) -> String { + metadata + .value(MetadataField::ApplicationName) + .or_else(|| metadata.value(MetadataField::MediaName)) + .or_else(|| metadata.value(MetadataField::ProcessBinary)) + .map_or_else(|| format!("Stream {}", handle.backend_id()), str::to_owned) +} diff --git a/fader_master/tests/live_mixer.rs b/fader_master/tests/live_mixer.rs new file mode 100644 index 0000000..220eacf --- /dev/null +++ b/fader_master/tests/live_mixer.rs @@ -0,0 +1,108 @@ +use fader_core::{ + AdapterEvent, BackendEpoch, ChannelGains, Gain, Mute, StreamHandle, StreamMetadata, +}; +use fader_master::{ + ipc::{ClientRequest, PROTOCOL_VERSION, RequestCommand, ResponseResult}, + live::LiveMixerState, +}; +use volume_lib::WorkerEvent; + +fn gain(value: f64) -> Gain { + Gain::new(value).unwrap() +} + +fn stream() -> StreamHandle { + StreamHandle::new(BackendEpoch::new(1), 12, 1) +} + +fn observed(operation: Option) -> WorkerEvent { + WorkerEvent::Adapter(AdapterEvent::Observed { + stream: stream(), + channels: ChannelGains::new(vec![gain(0.4), gain(0.2)]).unwrap(), + muted: Mute::Unmuted, + operation, + }) +} + +fn ready_state() -> LiveMixerState { + let mut state = LiveMixerState::new(Gain::UNITY, "pulse"); + state + .worker_event(WorkerEvent::StreamMetadata { + stream: stream(), + metadata: StreamMetadata::new() + .with_application_name("Music") + .with_process_binary("player"), + volume_writable: true, + }) + .unwrap(); + state.worker_event(observed(None)).unwrap(); + state + .worker_event(WorkerEvent::SnapshotEnd(BackendEpoch::new(1))) + .unwrap(); + state +} + +#[test] +fn observations_publish_labeled_revisioned_streams() { + let state = ready_state(); + let snapshot = state.snapshot(); + assert_eq!(snapshot.status, "ready"); + assert_eq!(snapshot.streams.len(), 1); + assert_eq!(snapshot.streams[0].label, "Music"); + assert_eq!(snapshot.streams[0].process.as_deref(), Some("player")); + assert_eq!(snapshot.streams[0].gain, 0.4); + assert!(!snapshot.streams[0].muted); + assert!(snapshot.revision > 0); +} + +#[test] +fn client_volume_is_pending_until_correlated_readback() { + let mut state = ready_state(); + let snapshot = state.snapshot(); + let request = ClientRequest { + version: PROTOCOL_VERSION, + request_id: 8, + command: RequestCommand::SetVolume { + stream: snapshot.streams[0].stream, + gain: 0.75, + expected_revision: snapshot.revision, + }, + }; + let (response, commands) = state.request(request).unwrap(); + assert_eq!(commands.len(), 1); + assert!(matches!(response.result, ResponseResult::Snapshot { .. })); + assert!(state.snapshot().streams[0].pending); + + let operation = match commands[0] { + fader_core::AdapterCommand::SetVolume { operation, .. } => operation, + _ => panic!("expected volume command"), + }; + let readback = state + .worker_event(WorkerEvent::Adapter(AdapterEvent::WriteAccepted { + operation, + })) + .unwrap(); + assert!(matches!( + readback.as_slice(), + [fader_core::AdapterCommand::Readback { .. }] + )); + state.worker_event(observed(Some(operation))).unwrap(); + assert!(!state.snapshot().streams[0].pending); +} + +#[test] +fn stale_client_revision_is_rejected_for_resnapshot() { + let mut state = ready_state(); + let stream = state.snapshot().streams[0].stream; + let error = state + .request(ClientRequest { + version: PROTOCOL_VERSION, + request_id: 9, + command: RequestCommand::ToggleMute { + stream, + expected_revision: 0, + }, + }) + .unwrap_err(); + assert!(error.to_string().contains("stale revision")); +}