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
This commit is contained in:
Dandaedre 2026-10-15 00:12:08 +02:00
parent b4870a67b9
commit a01e451643
Signed by: Dandaedre
GPG Key ID: 440C6592E8A26D99
3 changed files with 313 additions and 0 deletions

View File

@ -4,6 +4,7 @@
pub mod cli;
pub mod ipc;
pub mod live;
use std::{collections::BTreeMap, error::Error, fmt};

204
fader_master/src/live.rs Normal file
View File

@ -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<StreamHandle, MetadataView>,
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<String>) -> 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<Vec<AdapterCommand>, 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<AdapterCommand>), 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)
}

View File

@ -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<fader_core::OperationId>) -> 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"));
}