fader_master/config/src/state.rs

471 lines
15 KiB
Rust

use std::collections::BTreeSet;
use fader_core::{ApplicationId, ChannelGains, Gain, ProfileId, SurfaceId};
use serde::{Deserialize, Serialize};
use crate::{ConfigError, SCHEMA_VERSION, profile::parse_id};
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
struct ObservedObject {
object: String,
gain: Vec<f64>,
muted: bool,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
struct DesiredObject {
object: String,
#[serde(skip_serializing_if = "Option::is_none")]
gain: Option<f64>,
#[serde(skip_serializing_if = "Option::is_none")]
muted: Option<bool>,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
struct Assignment {
surface: String,
input_port: String,
#[serde(skip_serializing_if = "Option::is_none")]
output_port: Option<String>,
}
/// Last selected TUI view for a profile.
#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(rename_all = "snake_case")]
pub enum UiView {
/// Mixer overview.
Mixer,
/// MIDI surface assignment and status.
Devices,
/// Runtime diagnostics.
Status,
/// Configuration editor.
Editor,
}
/// Durable state for one stable profile; observed values are cache-only.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct ProfileState {
id: String,
last_view: UiView,
#[serde(default)]
observed: Vec<ObservedObject>,
#[serde(default)]
desired: Vec<DesiredObject>,
#[serde(default)]
assignments: Vec<Assignment>,
}
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
struct RawState {
schema_version: u16,
#[serde(default)]
profiles: Vec<ProfileState>,
}
/// Strict durable state without runtime handles, generations, or operations.
#[derive(Clone, Debug, PartialEq)]
pub struct PersistedState {
raw: RawState,
}
impl PersistedState {
/// Parses and validates cached observations, desired state, and assignments.
pub fn parse(input: &str) -> Result<Self, ConfigError> {
let raw: RawState = toml::from_str(input)?;
if raw.schema_version != SCHEMA_VERSION {
return Err(ConfigError::validation(
"schema_version",
format!(
"unsupported version {}; expected {SCHEMA_VERSION}",
raw.schema_version
),
));
}
validate_profiles(&raw.profiles)?;
Ok(Self { raw })
}
/// Serializes a canonical representation.
pub fn to_toml(&self) -> Result<String, ConfigError> {
Ok(toml::to_string_pretty(&self.raw)?)
}
/// Per-profile state in stable order.
pub fn profiles(&self) -> &[ProfileState] {
&self.raw.profiles
}
/// Records the latest durable object intent independently of observations.
pub fn set_desired(
&mut self,
profile_id: &str,
object_id: &str,
gain: Option<f64>,
muted: Option<bool>,
) -> Result<(), ConfigError> {
parse_id::<ApplicationId>(object_id, "desired.object")?;
if gain.is_none() && muted.is_none() {
return Err(ConfigError::validation(
"desired",
"at least one desired gain or mute value is required",
));
}
if let Some(value) = gain {
Gain::new(value)
.map_err(|error| ConfigError::validation("desired.gain", error.to_string()))?;
}
let profile = self
.raw
.profiles
.iter_mut()
.find(|profile| profile.id == profile_id)
.ok_or_else(|| {
ConfigError::validation("profile", format!("unknown profile {profile_id:?}"))
})?;
if let Some(desired) = profile
.desired
.iter_mut()
.find(|desired| desired.object == object_id)
{
desired.gain = gain;
desired.muted = muted;
} else {
profile.desired.push(DesiredObject {
object: object_id.to_owned(),
gain,
muted,
});
}
Ok(())
}
/// Records a confirmed per-channel observation without a runtime handle.
pub fn set_observed(
&mut self,
profile_id: &str,
object_id: &str,
channels: &[f64],
muted: bool,
) -> Result<(), ConfigError> {
parse_id::<ApplicationId>(object_id, "observed.object")?;
let gains = channels
.iter()
.copied()
.map(Gain::new)
.collect::<Result<Vec<_>, _>>()
.map_err(|error| ConfigError::validation("observed.gain", error.to_string()))?;
let validated = ChannelGains::new(gains)
.map_err(|error| ConfigError::validation("observed.gain", error.to_string()))?;
let profile = find_profile_mut(&mut self.raw.profiles, profile_id)?;
let gain = validated.as_slice().iter().map(|gain| gain.get()).collect();
if let Some(observed) = profile
.observed
.iter_mut()
.find(|observed| observed.object == object_id)
{
observed.gain = gain;
observed.muted = muted;
} else {
profile.observed.push(ObservedObject {
object: object_id.to_owned(),
gain,
muted,
});
}
Ok(())
}
/// Remembers stable surface-to-port assignment hints for one profile.
pub fn set_surface_assignment(
&mut self,
profile_id: &str,
surface_id: &str,
input_port: &str,
output_port: Option<&str>,
) -> Result<(), ConfigError> {
parse_id::<SurfaceId>(surface_id, "assignment.surface")?;
if input_port.is_empty() || output_port.is_some_and(str::is_empty) {
return Err(ConfigError::validation(
"assignment.port",
"configured port names must not be empty",
));
}
let profile = find_profile_mut(&mut self.raw.profiles, profile_id)?;
let output_port = output_port.map(str::to_owned);
if let Some(assignment) = profile
.assignments
.iter_mut()
.find(|assignment| assignment.surface == surface_id)
{
assignment.input_port = input_port.to_owned();
assignment.output_port = output_port;
} else {
profile.assignments.push(Assignment {
surface: surface_id.to_owned(),
input_port: input_port.to_owned(),
output_port,
});
}
Ok(())
}
/// Updates the remembered UI view for one profile.
pub fn set_last_view(&mut self, profile_id: &str, view: UiView) -> Result<(), ConfigError> {
find_profile_mut(&mut self.raw.profiles, profile_id)?.last_view = view;
Ok(())
}
/// Creates restart state whose observations are always explicitly stale.
pub fn startup(
&self,
profile_id: &str,
policy: crate::StartupPolicy,
write_ceiling: f64,
) -> Result<StartupState, ConfigError> {
let write_ceiling = Gain::new(write_ceiling)
.map_err(|error| ConfigError::validation("write_ceiling", error.to_string()))?;
let profile = self
.raw
.profiles
.iter()
.find(|profile| profile.id == profile_id)
.ok_or_else(|| {
ConfigError::validation("profile", format!("unknown profile {profile_id:?}"))
})?;
let cached_observations = profile
.observed
.iter()
.map(|observation| CachedObservation {
object: observation.object.clone(),
gain: observation.gain.clone(),
muted: observation.muted,
stale: true,
})
.collect();
let desired = profile
.desired
.iter()
.enumerate()
.map(|(index, intent)| {
if intent.gain.is_some_and(|gain| gain > write_ceiling.get()) {
return Err(ConfigError::validation(
format!("profiles.desired[{index}].gain"),
format!("exceeds write ceiling {}", write_ceiling.get()),
));
}
Ok(DesiredWrite {
object: intent.object.clone(),
gain: intent.gain,
muted: intent.muted,
})
})
.collect::<Result<Vec<_>, _>>()?;
Ok(StartupState {
policy,
cached_observations,
desired,
})
}
}
/// A restart-only observation that cannot be mistaken for current backend data.
#[derive(Clone, Debug, PartialEq)]
pub struct CachedObservation {
object: String,
gain: Vec<f64>,
muted: bool,
stale: bool,
}
impl CachedObservation {
/// Stable virtual object identifier.
pub fn object(&self) -> &str {
&self.object
}
/// Cached per-channel gains retained for display only.
pub fn gain(&self) -> &[f64] {
&self.gain
}
/// Cached mute observation.
pub const fn muted(&self) -> bool {
self.muted
}
/// Cached observations are always stale until live discovery replaces them.
pub const fn is_stale(&self) -> bool {
self.stale
}
}
/// A validated desired object write, with absent properties left unchanged.
#[derive(Clone, Debug, PartialEq)]
pub struct DesiredWrite {
object: String,
gain: Option<f64>,
muted: Option<bool>,
}
impl DesiredWrite {
/// Stable virtual object identifier.
pub fn object(&self) -> &str {
&self.object
}
/// Desired scalar gain, when one was saved.
pub const fn gain(&self) -> Option<f64> {
self.gain
}
/// Desired mute state, when one was saved.
pub const fn muted(&self) -> Option<bool> {
self.muted
}
}
/// Validated restart data with an explicit adopt/restore policy.
#[derive(Clone, Debug, PartialEq)]
pub struct StartupState {
policy: crate::StartupPolicy,
cached_observations: Vec<CachedObservation>,
desired: Vec<DesiredWrite>,
}
impl StartupState {
/// Observations retained for display but never treated as fresh.
pub fn cached_observations(&self) -> &[CachedObservation] {
&self.cached_observations
}
/// Saved intents remain visible even when startup adopts live state.
pub fn desired_intents(&self) -> &[DesiredWrite] {
&self.desired
}
/// Returns the explicit write for a newly discovered application only when
/// the profile selected restore policy.
pub fn application_joined(&self, application_id: &str) -> Vec<DesiredWrite> {
if self.policy != crate::StartupPolicy::Restore {
return Vec::new();
}
self.desired
.iter()
.filter(|intent| intent.object == application_id)
.cloned()
.collect()
}
}
fn validate_profiles(profiles: &[ProfileState]) -> Result<(), ConfigError> {
let mut profile_ids = BTreeSet::new();
for (profile_index, profile) in profiles.iter().enumerate() {
parse_id::<ProfileId>(&profile.id, &format!("profiles[{profile_index}].id"))?;
if !profile_ids.insert(&profile.id) {
return Err(ConfigError::validation(
format!("profiles[{profile_index}].id"),
"duplicate profile state",
));
}
validate_observed(profile_index, &profile.observed)?;
validate_desired(profile_index, &profile.desired)?;
validate_assignments(profile_index, &profile.assignments)?;
}
Ok(())
}
fn validate_observed(profile: usize, objects: &[ObservedObject]) -> Result<(), ConfigError> {
let mut ids = BTreeSet::new();
for (index, object) in objects.iter().enumerate() {
let base = format!("profiles[{profile}].observed[{index}]");
parse_id::<ApplicationId>(&object.object, &format!("{base}.object"))?;
if !ids.insert(&object.object) {
return Err(ConfigError::validation(
format!("{base}.object"),
"duplicate observed object",
));
}
let gains = object
.gain
.iter()
.copied()
.map(Gain::new)
.collect::<Result<Vec<_>, _>>()
.map_err(|error| ConfigError::validation(format!("{base}.gain"), error.to_string()))?;
ChannelGains::new(gains)
.map_err(|error| ConfigError::validation(format!("{base}.gain"), error.to_string()))?;
}
Ok(())
}
fn validate_desired(profile: usize, objects: &[DesiredObject]) -> Result<(), ConfigError> {
let mut ids = BTreeSet::new();
for (index, object) in objects.iter().enumerate() {
let base = format!("profiles[{profile}].desired[{index}]");
parse_id::<ApplicationId>(&object.object, &format!("{base}.object"))?;
if !ids.insert(&object.object) {
return Err(ConfigError::validation(
format!("{base}.object"),
"duplicate desired object",
));
}
if object.gain.is_none() && object.muted.is_none() {
return Err(ConfigError::validation(
base,
"at least one desired gain or mute value is required",
));
}
if let Some(gain) = object.gain {
Gain::new(gain).map_err(|error| {
ConfigError::validation(format!("{base}.gain"), error.to_string())
})?;
}
}
Ok(())
}
fn validate_assignments(profile: usize, assignments: &[Assignment]) -> Result<(), ConfigError> {
let mut ids = BTreeSet::new();
for (index, assignment) in assignments.iter().enumerate() {
let base = format!("profiles[{profile}].assignments[{index}]");
parse_id::<SurfaceId>(&assignment.surface, &format!("{base}.surface"))?;
if !ids.insert(&assignment.surface) {
return Err(ConfigError::validation(
format!("{base}.surface"),
"duplicate surface assignment",
));
}
if assignment.input_port.is_empty() {
return Err(ConfigError::validation(
format!("{base}.input_port"),
"must not be empty",
));
}
if assignment.output_port.as_deref().is_some_and(str::is_empty) {
return Err(ConfigError::validation(
format!("{base}.output_port"),
"must not be empty when present",
));
}
}
Ok(())
}
fn find_profile_mut<'a>(
profiles: &'a mut [ProfileState],
profile_id: &str,
) -> Result<&'a mut ProfileState, ConfigError> {
profiles
.iter_mut()
.find(|profile| profile.id == profile_id)
.ok_or_else(|| {
ConfigError::validation("profile", format!("unknown profile {profile_id:?}"))
})
}