use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
use std::path::PathBuf;
use crate::serial::PortInfo;
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct Profile {
pub name: String,
#[serde(default)]
pub selector: ProfileSelector,
#[serde(default)]
pub defaults: ProfileDefaults,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
pub struct ProfileSelector {
#[schemars(schema_with = "crate::schema_helpers::option_uint_schema")]
pub vid: Option<u16>,
#[schemars(schema_with = "crate::schema_helpers::option_uint_schema")]
pub pid: Option<u16>,
pub serial_number: Option<String>,
pub manufacturer: Option<String>,
pub product: Option<String>,
#[schemars(schema_with = "crate::schema_helpers::option_uint_schema")]
pub interface: Option<u8>,
pub port_pattern: Option<String>,
pub description_pattern: Option<String>,
pub transport: Option<String>,
pub hardware_id: Option<String>,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
pub struct ProfileDefaults {
#[schemars(schema_with = "crate::schema_helpers::uint_schema")]
#[serde(default = "default_baud")]
pub baud_rate: u32,
#[serde(default = "default_data_bits")]
pub data_bits: String,
#[serde(default = "default_stop_bits")]
pub stop_bits: String,
#[serde(default = "default_parity")]
pub parity: String,
#[serde(default = "default_flow_control")]
pub flow_control: String,
pub name: Option<String>,
#[serde(default)]
pub tx_framing: Option<crate::framing::TxFramingConfig>,
#[serde(default)]
pub rx_framing: Option<crate::framing::RxFramingConfig>,
#[serde(default)]
pub rx_parser: Option<crate::framing::ParserConfig>,
#[serde(default)]
pub protocol: Option<crate::framing::ProtocolPreset>,
}
fn default_baud() -> u32 {
115200
}
fn default_data_bits() -> String {
"8".into()
}
fn default_stop_bits() -> String {
"1".into()
}
fn default_parity() -> String {
"none".into()
}
fn default_flow_control() -> String {
"none".into()
}
impl Default for ProfileDefaults {
fn default() -> Self {
Self {
baud_rate: default_baud(),
data_bits: default_data_bits(),
stop_bits: default_stop_bits(),
parity: default_parity(),
flow_control: default_flow_control(),
name: None,
tx_framing: None,
rx_framing: None,
rx_parser: None,
protocol: None,
}
}
}
impl Profile {
pub fn matches(&self, port: &PortInfo) -> bool {
let s = &self.selector;
if let Some(vid) = s.vid {
if port.vid != Some(vid) {
return false;
}
}
if let Some(pid) = s.pid {
if port.pid != Some(pid) {
return false;
}
}
if let Some(ref want) = s.serial_number {
if port.serial_number.as_deref() != Some(want.as_str()) {
return false;
}
}
if let Some(ref want) = s.manufacturer {
if port.manufacturer.as_deref() != Some(want.as_str()) {
return false;
}
}
if let Some(ref want) = s.product {
if port.product.as_deref() != Some(want.as_str()) {
return false;
}
}
if let Some(iface) = s.interface {
if port.interface != Some(iface) {
return false;
}
}
if let Some(ref pattern) = s.port_pattern {
if !glob::Pattern::new(pattern)
.map(|p| p.matches(&port.name))
.unwrap_or(false)
{
return false;
}
}
if let Some(ref pattern) = s.description_pattern {
if !glob::Pattern::new(pattern)
.map(|p| p.matches(&port.description))
.unwrap_or(false)
{
return false;
}
}
if let Some(ref want) = s.transport {
if port.transport.to_string().as_str() != want.as_str() {
return false;
}
}
if let Some(ref want) = s.hardware_id {
if port.hardware_id.as_deref() != Some(want.as_str()) {
return false;
}
}
true
}
}
pub fn load_profiles(path: &PathBuf) -> Vec<Profile> {
let content = match std::fs::read_to_string(path) {
Ok(c) => c,
Err(e) => {
tracing::warn!("Cannot read profiles file {}: {e}", path.display());
return vec![];
}
};
match toml::from_str::<ProfilesFile>(&content) {
Ok(f) => f.profile,
Err(e) => {
tracing::warn!("Failed to parse profiles file {}: {e}", path.display());
vec![]
}
}
}
pub fn default_profiles_path() -> PathBuf {
let mut p = dirs::config_dir().unwrap_or_else(|| PathBuf::from("."));
p.push("serial-mcp");
p.push("profiles.toml");
p
}
pub fn save_profile(path: &PathBuf, profile: &Profile, overwrite: bool) -> Result<bool, String> {
let mut profiles = load_profiles(path);
let existing_idx = profiles.iter().position(|p| p.name == profile.name);
if existing_idx.is_some() && !overwrite {
return Err(format!(
"Profile '{}' already exists. Set overwrite=true to replace.",
profile.name
));
}
match existing_idx {
Some(idx) => {
profiles[idx] = profile.clone();
}
None => {
profiles.push(profile.clone());
}
}
let created = existing_idx.is_none();
let toml = toml::to_string_pretty(&ProfilesFile { profile: profiles })
.map_err(|e| format!("Failed to serialize profiles: {e}"))?;
let dir = path
.parent()
.ok_or_else(|| "Profiles path has no parent directory".to_string())?;
std::fs::create_dir_all(dir).map_err(|e| format!("Cannot create profile dir: {e}"))?;
let mut tmp = tempfile::NamedTempFile::new_in(dir)
.map_err(|e| format!("Failed to create temp file: {e}"))?;
std::io::Write::write_all(&mut tmp, toml.as_bytes())
.map_err(|e| format!("Failed to write profiles: {e}"))?;
tmp.persist(path)
.map_err(|e| format!("Failed to commit profiles: {e}"))?;
tracing::info!(
"Profile '{}' {} (path: {})",
profile.name,
if created { "created" } else { "updated" },
path.display()
);
Ok(created)
}
pub fn delete_profile(path: &PathBuf, name: &str) -> Result<(), String> {
let mut profiles = load_profiles(path);
let len_before = profiles.len();
profiles.retain(|p| p.name != name);
if profiles.len() == len_before {
return Err(format!("Profile '{name}' not found"));
}
let toml = toml::to_string_pretty(&ProfilesFile { profile: profiles })
.map_err(|e| format!("Failed to serialize profiles: {e}"))?;
let dir = path
.parent()
.ok_or_else(|| "Profiles path has no parent directory".to_string())?;
std::fs::create_dir_all(dir).map_err(|e| format!("Cannot create profile dir: {e}"))?;
let mut tmp = tempfile::NamedTempFile::new_in(dir)
.map_err(|e| format!("Failed to create temp file: {e}"))?;
std::io::Write::write_all(&mut tmp, toml.as_bytes())
.map_err(|e| format!("Failed to write profiles: {e}"))?;
tmp.persist(path)
.map_err(|e| format!("Failed to commit profiles: {e}"))?;
tracing::info!("Profile '{}' deleted (path: {})", name, path.display());
Ok(())
}
#[derive(Debug, Deserialize, Serialize)]
struct ProfilesFile {
profile: Vec<Profile>,
}
#[cfg(test)]
mod tests {
use super::*;
fn make_port(name: &str, vid: Option<u16>, pid: Option<u16>, serial: Option<&str>) -> PortInfo {
PortInfo {
name: name.into(),
display_name: name.rsplit('/').next().unwrap_or(name).into(),
description: "Test Port".into(),
hardware_id: None,
transport: crate::serial::PortTransport::Usb,
vid,
pid,
serial_number: serial.map(str::to_string),
manufacturer: None,
product: None,
interface: None,
}
}
#[test]
fn empty_selector_matches_any_port() {
let p = Profile {
name: "any".into(),
selector: ProfileSelector::default(),
defaults: ProfileDefaults::default(),
};
assert!(p.matches(&make_port("/dev/ttyUSB0", Some(0x1234), Some(0x5678), None)));
assert!(p.matches(&make_port("/dev/ttyACM0", None, None, None)));
}
#[test]
fn exact_vid_pid_match() {
let p = Profile {
name: "my-device".into(),
selector: ProfileSelector {
vid: Some(0x1234),
pid: Some(0x5678),
..Default::default()
},
defaults: ProfileDefaults::default(),
};
assert!(p.matches(&make_port("/dev/ttyUSB0", Some(0x1234), Some(0x5678), None)));
assert!(!p.matches(&make_port("/dev/ttyUSB0", Some(0xAAAA), Some(0x5678), None)));
assert!(!p.matches(&make_port("/dev/ttyUSB0", None, None, None)));
}
#[test]
fn serial_number_match() {
let p = Profile {
name: "by-serial".into(),
selector: ProfileSelector {
serial_number: Some("0001".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
};
assert!(p.matches(&make_port("/dev/ttyUSB0", None, None, Some("0001"))));
assert!(!p.matches(&make_port("/dev/ttyUSB0", None, None, Some("0002"))));
assert!(!p.matches(&make_port("/dev/ttyUSB0", None, None, None)));
}
#[test]
fn port_pattern_glob_match() {
let p = Profile {
name: "acm-only".into(),
selector: ProfileSelector {
port_pattern: Some("/dev/ttyACM*".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
};
assert!(p.matches(&make_port("/dev/ttyACM0", None, None, None)));
assert!(!p.matches(&make_port("/dev/ttyUSB0", None, None, None)));
}
#[test]
fn multiple_fields_all_must_match() {
let p = Profile {
name: "specific".into(),
selector: ProfileSelector {
vid: Some(0x1234),
serial_number: Some("0001".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
};
assert!(p.matches(&make_port(
"/dev/ttyUSB0",
Some(0x1234),
Some(0x9999),
Some("0001")
)));
assert!(!p.matches(&make_port(
"/dev/ttyUSB0",
Some(0x1234),
Some(0x9999),
Some("0002")
)));
assert!(!p.matches(&make_port(
"/dev/ttyUSB0",
Some(0xAAAA),
Some(0x9999),
Some("0001")
)));
}
#[test]
fn load_profiles_from_toml() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("profiles.toml");
std::fs::write(
&path,
r#"
[[profile]]
name = "nrf-dk"
[profile.selector]
vid = 0x1366
pid = 0x0105
[profile.defaults]
baud_rate = 115200
name = "nrf"
[[profile]]
name = "arduino"
[profile.selector]
port_pattern = "/dev/ttyACM*"
[profile.defaults]
baud_rate = 9600
"#,
)
.unwrap();
let profiles = load_profiles(&path);
assert_eq!(profiles.len(), 2);
assert_eq!(profiles[0].name, "nrf-dk");
assert_eq!(profiles[0].selector.vid, Some(0x1366));
assert_eq!(profiles[0].defaults.name.as_deref(), Some("nrf"));
assert_eq!(profiles[1].name, "arduino");
}
#[test]
fn manufacturer_match() {
let p = Profile {
name: "by-mfg".into(),
selector: ProfileSelector {
manufacturer: Some("STMicro".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
};
let mut port = make_port("/dev/ttyACM0", None, None, None);
port.manufacturer = Some("STMicro".into());
assert!(p.matches(&port));
port.manufacturer = Some("Other".into());
assert!(!p.matches(&port));
}
#[test]
fn product_match() {
let p = Profile {
name: "by-prod".into(),
selector: ProfileSelector {
product: Some("VirtualCom".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
};
let mut port = make_port("/dev/ttyACM0", None, None, None);
port.product = Some("VirtualCom".into());
assert!(p.matches(&port));
port.product = Some("Other".into());
assert!(!p.matches(&port));
}
#[test]
fn interface_match() {
let p = Profile {
name: "by-iface".into(),
selector: ProfileSelector {
interface: Some(2),
..Default::default()
},
defaults: ProfileDefaults::default(),
};
let mut port = make_port("/dev/ttyACM0", None, None, None);
port.interface = Some(2);
assert!(p.matches(&port));
port.interface = Some(0);
assert!(!p.matches(&port));
}
#[test]
fn description_pattern_match() {
let p = Profile {
name: "by-desc".into(),
selector: ProfileSelector {
description_pattern: Some("*CP210*".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
};
let port = PortInfo {
description: "Silicon Labs CP2102 USB to UART Bridge Controller".into(),
..make_port("/dev/ttyUSB0", None, None, None)
};
assert!(p.matches(&port));
assert!(!p.matches(&make_port("/dev/ttyUSB0", None, None, None)));
}
#[test]
fn invalid_glob_pattern_returns_false() {
let p = Profile {
name: "bad-glob".into(),
selector: ProfileSelector {
port_pattern: Some("[unclosed".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
};
assert!(!p.matches(&make_port("/dev/ttyUSB0", None, None, None)));
}
#[test]
fn load_profiles_missing_file_returns_empty() {
let profiles = load_profiles(&PathBuf::from("/nonexistent/path/profiles.toml"));
assert!(profiles.is_empty());
}
#[test]
fn load_profiles_invalid_toml_returns_empty() {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("bad.toml");
std::fs::write(&path, "not valid toml {{{").unwrap();
let profiles = load_profiles(&path);
assert!(profiles.is_empty());
}
fn temp_profiles_path() -> PathBuf {
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("profiles.toml");
std::mem::forget(dir);
path
}
fn make_test_profile(name: &str) -> Profile {
Profile {
name: name.into(),
selector: ProfileSelector {
vid: Some(0x1234),
..Default::default()
},
defaults: ProfileDefaults::default(),
}
}
#[test]
fn save_profile_creates_new() {
let path = temp_profiles_path();
let profile = make_test_profile("test-device");
let created = save_profile(&path, &profile, false).unwrap();
assert!(created, "new profile should report created=true");
let loaded = load_profiles(&path);
assert_eq!(loaded.len(), 1);
assert_eq!(loaded[0].name, "test-device");
assert_eq!(loaded[0].selector.vid, Some(0x1234));
}
#[test]
fn save_profile_overwrites_existing() {
let path = temp_profiles_path();
save_profile(&path, &make_test_profile("test-device"), false).unwrap();
let mut updated = make_test_profile("test-device");
updated.defaults.baud_rate = 9600;
let created = save_profile(&path, &updated, true).unwrap();
assert!(!created, "overwrite should report created=false");
let loaded = load_profiles(&path);
assert_eq!(loaded.len(), 1);
assert_eq!(loaded[0].defaults.baud_rate, 9600);
}
#[test]
fn save_profile_rejects_existing_without_overwrite() {
let path = temp_profiles_path();
save_profile(&path, &make_test_profile("test-device"), false).unwrap();
let result = save_profile(&path, &make_test_profile("test-device"), false);
assert!(
result.is_err(),
"should reject duplicate without overwrite flag"
);
}
#[test]
fn save_profile_appends_second_profile() {
let path = temp_profiles_path();
save_profile(&path, &make_test_profile("dev-a"), false).unwrap();
save_profile(&path, &make_test_profile("dev-b"), false).unwrap();
let loaded = load_profiles(&path);
assert_eq!(loaded.len(), 2);
}
#[test]
fn delete_profile_removes_existing() {
let path = temp_profiles_path();
save_profile(&path, &make_test_profile("dev-a"), false).unwrap();
save_profile(&path, &make_test_profile("dev-b"), false).unwrap();
delete_profile(&path, "dev-a").unwrap();
let loaded = load_profiles(&path);
assert_eq!(loaded.len(), 1);
assert_eq!(loaded[0].name, "dev-b");
}
#[test]
fn delete_profile_nonexistent_returns_error() {
let path = temp_profiles_path();
let result = delete_profile(&path, "no-such-profile");
assert!(result.is_err());
}
#[test]
fn transport_match_usb() {
let p = Profile {
name: "usb-only".into(),
selector: ProfileSelector {
transport: Some("usb".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
};
assert!(p.matches(&make_port("/dev/ttyACM0", None, None, None)));
let mut pci_port = make_port("/dev/ttyS0", None, None, None);
pci_port.transport = crate::serial::PortTransport::Pci;
assert!(!p.matches(&pci_port));
}
#[test]
fn transport_match_unknown() {
let p = Profile {
name: "unknown-only".into(),
selector: ProfileSelector {
transport: Some("unknown".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
};
let mut unknown_port = make_port("/dev/ttyX", None, None, None);
unknown_port.transport = crate::serial::PortTransport::Unknown;
assert!(p.matches(&unknown_port));
}
#[test]
fn transport_match_case_sensitive() {
let p = Profile {
name: "usb-exact".into(),
selector: ProfileSelector {
transport: Some("USB".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
};
assert!(!p.matches(&make_port("/dev/ttyACM0", None, None, None)));
}
#[test]
fn hardware_id_match() {
let p = Profile {
name: "by-hwid".into(),
selector: ProfileSelector {
hardware_id: Some("USB\\VID_1234&PID_5678".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
};
let mut port = make_port("/dev/ttyACM0", None, None, None);
port.hardware_id = Some("USB\\VID_1234&PID_5678".into());
assert!(p.matches(&port));
port.hardware_id = Some("USB\\VID_AAAA&PID_BBBB".into());
assert!(!p.matches(&port));
}
#[test]
fn hardware_id_no_match_when_port_has_none() {
let p = Profile {
name: "hwid-required".into(),
selector: ProfileSelector {
hardware_id: Some("USB\\VID_1234&PID_5678".into()),
..Default::default()
},
defaults: ProfileDefaults::default(),
};
assert!(!p.matches(&make_port("/dev/ttyACM0", None, None, None)));
}
#[test]
fn profile_defaults_has_no_dead_fields() {
let json = serde_json::json!({
"reconnect_policy": "x",
"decoder": "y",
"safety_policy": "z"
});
let _: ProfileDefaults =
serde_json::from_value(json).expect("dead fields must be silently ignored");
let value = serde_json::to_value(ProfileDefaults::default())
.expect("ProfileDefaults must serialize");
let obj = value
.as_object()
.expect("serialized ProfileDefaults must be an object");
assert!(!obj.contains_key("reconnect_policy"));
assert!(!obj.contains_key("decoder"));
assert!(!obj.contains_key("safety_policy"));
}
}