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:
parent
b4870a67b9
commit
a01e451643
|
|
@ -4,6 +4,7 @@
|
|||
|
||||
pub mod cli;
|
||||
pub mod ipc;
|
||||
pub mod live;
|
||||
|
||||
use std::{collections::BTreeMap, error::Error, fmt};
|
||||
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
}
|
||||
|
|
@ -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"));
|
||||
}
|
||||
Loading…
Reference in New Issue