From 133a367a368ce6a043669c86ccc4455ffd1e4abe Mon Sep 17 00:00:00 2001 From: Chris Beck Date: Sat, 6 Dec 2025 10:12:33 -0700 Subject: [PATCH] rename struct to signal trust set --- signal-gateway/src/gateway/mod.rs | 6 +-- .../{admin_uuids.rs => signal_trust_set.rs} | 42 +++++++++---------- 2 files changed, 24 insertions(+), 24 deletions(-) rename signal-gateway/src/gateway/{admin_uuids.rs => signal_trust_set.rs} (77%) diff --git a/signal-gateway/src/gateway/mod.rs b/signal-gateway/src/gateway/mod.rs index d58ce2a..1f93856 100644 --- a/signal-gateway/src/gateway/mod.rs +++ b/signal-gateway/src/gateway/mod.rs @@ -28,8 +28,8 @@ use tokio::{ use tokio_util::{bytes::Buf, sync::CancellationToken}; use tracing::{debug, error, info, warn}; -mod admin_uuids; -pub use admin_uuids::AdminSignalUuids; +mod signal_trust_set; +pub use signal_trust_set::SignalTrustSet; mod log_buffer; mod log_handler; @@ -65,7 +65,7 @@ pub struct GatewayConfig { /// Admin UUIDs mapped to their safety numbers (can be empty). /// Accepts either a map `{"uuid1": ["12345..."], "uuid2": []}` or a list `["uuid1", "uuid2"]`. #[conf(long, env, value_parser = serde_json::from_str)] - pub admin_signal_uuids: AdminSignalUuids, + pub admin_signal_uuids: SignalTrustSet, /// If set, alerts are sent to this group instead of individual admins. #[conf(long, env)] pub alert_group_id: Option, diff --git a/signal-gateway/src/gateway/admin_uuids.rs b/signal-gateway/src/gateway/signal_trust_set.rs similarity index 77% rename from signal-gateway/src/gateway/admin_uuids.rs rename to signal-gateway/src/gateway/signal_trust_set.rs index ee0f36a..523979f 100644 --- a/signal-gateway/src/gateway/admin_uuids.rs +++ b/signal-gateway/src/gateway/signal_trust_set.rs @@ -1,25 +1,25 @@ -//! Admin Signal UUIDs container with flexible deserialization. +//! Signal trust set - a set of Signal UUIDs with optional safety numbers. //! -//! Supports two formats: -//! - Map: `{"uuid1": ["safety1", "safety2"], "uuid2": []}` -//! - Sequence: `["uuid1", "uuid2"]` (treated as UUIDs with no safety numbers) +//! Supports two deserialization formats: +//! - Map: `{"uuid1": ["safety1", "safety2"], "uuid2": []}` - UUIDs with safety numbers +//! - Sequence: `["uuid1", "uuid2"]` - UUIDs with no safety numbers (simpler) use serde::de::{MapAccess, SeqAccess, Visitor}; use serde::{Deserialize, Deserializer}; use std::collections::HashMap; use std::fmt; -/// Container for admin Signal UUIDs mapped to their optional safety numbers. +/// A set of Signal UUIDs with optional safety numbers for trust verification. /// /// Can be deserialized from either: /// - A map of UUID -> safety numbers: `{"uuid1": ["12345..."], "uuid2": []}` /// - A sequence of UUIDs (no safety numbers): `["uuid1", "uuid2"]` #[derive(Clone, Debug, Default)] -pub struct AdminSignalUuids { +pub struct SignalTrustSet { map: HashMap>, } -impl AdminSignalUuids { +impl SignalTrustSet { /// Create an empty container. pub fn new() -> Self { Self::default() @@ -56,19 +56,19 @@ impl AdminSignalUuids { } } -impl<'de> Deserialize<'de> for AdminSignalUuids { +impl<'de> Deserialize<'de> for SignalTrustSet { fn deserialize(deserializer: D) -> Result where D: Deserializer<'de>, { - deserializer.deserialize_any(AdminSignalUuidsVisitor) + deserializer.deserialize_any(SignalTrustSetVisitor) } } -struct AdminSignalUuidsVisitor; +struct SignalTrustSetVisitor; -impl<'de> Visitor<'de> for AdminSignalUuidsVisitor { - type Value = AdminSignalUuids; +impl<'de> Visitor<'de> for SignalTrustSetVisitor { + type Value = SignalTrustSet; fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { formatter.write_str("a map of UUIDs to safety numbers, or a sequence of UUIDs") @@ -82,7 +82,7 @@ impl<'de> Visitor<'de> for AdminSignalUuidsVisitor { while let Some((key, value)) = access.next_entry::>()? { map.insert(key, value); } - Ok(AdminSignalUuids { map }) + Ok(SignalTrustSet { map }) } fn visit_seq(self, mut access: S) -> Result @@ -93,11 +93,11 @@ impl<'de> Visitor<'de> for AdminSignalUuidsVisitor { while let Some(uuid) = access.next_element::()? { map.insert(uuid, Vec::new()); } - Ok(AdminSignalUuids { map }) + Ok(SignalTrustSet { map }) } } -impl FromIterator for AdminSignalUuids { +impl FromIterator for SignalTrustSet { fn from_iter>(iter: I) -> Self { Self { map: iter.into_iter().map(|uuid| (uuid, Vec::new())).collect(), @@ -105,7 +105,7 @@ impl FromIterator for AdminSignalUuids { } } -impl FromIterator<(String, Vec)> for AdminSignalUuids { +impl FromIterator<(String, Vec)> for SignalTrustSet { fn from_iter)>>(iter: I) -> Self { Self { map: iter.into_iter().collect(), @@ -113,7 +113,7 @@ impl FromIterator<(String, Vec)> for AdminSignalUuids { } } -impl<'a> IntoIterator for &'a AdminSignalUuids { +impl<'a> IntoIterator for &'a SignalTrustSet { type Item = (&'a String, &'a Vec); type IntoIter = std::collections::hash_map::Iter<'a, String, Vec>; @@ -129,7 +129,7 @@ mod tests { #[test] fn test_deserialize_map() { let json = r#"{"uuid1": ["safety1", "safety2"], "uuid2": []}"#; - let uuids: AdminSignalUuids = serde_json::from_str(json).unwrap(); + let uuids: SignalTrustSet = serde_json::from_str(json).unwrap(); assert_eq!(uuids.len(), 2); assert!(uuids.contains("uuid1")); @@ -141,7 +141,7 @@ mod tests { #[test] fn test_deserialize_seq() { let json = r#"["uuid1", "uuid2", "uuid3"]"#; - let uuids: AdminSignalUuids = serde_json::from_str(json).unwrap(); + let uuids: SignalTrustSet = serde_json::from_str(json).unwrap(); assert_eq!(uuids.len(), 3); assert!(uuids.contains("uuid1")); @@ -156,14 +156,14 @@ mod tests { #[test] fn test_empty_map() { let json = r#"{}"#; - let uuids: AdminSignalUuids = serde_json::from_str(json).unwrap(); + let uuids: SignalTrustSet = serde_json::from_str(json).unwrap(); assert!(uuids.is_empty()); } #[test] fn test_empty_seq() { let json = r#"[]"#; - let uuids: AdminSignalUuids = serde_json::from_str(json).unwrap(); + let uuids: SignalTrustSet = serde_json::from_str(json).unwrap(); assert!(uuids.is_empty()); } }