use crate::{CanaryToken, Error, Result, TriggerSource};
use core::fmt;
use std::collections::HashMap;
use std::sync::{Arc, PoisonError, RwLock, RwLockReadGuard, RwLockWriteGuard};
pub struct CanaryRegistry {
inner: RwLock<RegistryInner>,
}
struct RegistryInner {
by_id: HashMap<String, Arc<CanaryToken>>,
by_name: HashMap<String, String>,
}
impl RegistryInner {
fn new() -> Self {
Self {
by_id: HashMap::new(),
by_name: HashMap::new(),
}
}
}
impl CanaryRegistry {
#[must_use]
pub fn new() -> Self {
Self {
inner: RwLock::new(RegistryInner::new()),
}
}
pub fn register(&self, token: CanaryToken) -> Result<String> {
self.register_shared(Arc::new(token))
}
pub fn register_shared(&self, token: Arc<CanaryToken>) -> Result<String> {
let mut inner = self.write_inner();
let name = token.name().to_owned();
if inner.by_name.contains_key(&name) {
return Err(Error::DuplicateName(name));
}
let id = token.id().to_owned();
if inner.by_id.contains_key(&id) {
return Err(Error::DuplicateId(id));
}
inner.by_name.insert(name, id.clone());
inner.by_id.insert(id.clone(), token);
Ok(id)
}
#[must_use]
pub fn get_by_id(&self, id: &str) -> Option<Arc<CanaryToken>> {
self.read_inner().by_id.get(id).cloned()
}
#[must_use]
pub fn get_by_name(&self, name: &str) -> Option<Arc<CanaryToken>> {
let inner = self.read_inner();
let id = inner.by_name.get(name)?;
inner.by_id.get(id).cloned()
}
#[must_use]
pub fn get(&self, id_or_name: &str) -> Option<Arc<CanaryToken>> {
self.get_by_id(id_or_name)
.or_else(|| self.get_by_name(id_or_name))
}
pub fn reveal(&self, id_or_name: &str) -> Result<String> {
let token = self
.get(id_or_name)
.ok_or_else(|| Error::NotFound(id_or_name.to_owned()))?;
Ok(token.reveal_with_source(TriggerSource::Registry))
}
pub fn trigger(&self, id_or_name: &str, source: TriggerSource) -> Result<()> {
let token = self
.get(id_or_name)
.ok_or_else(|| Error::NotFound(id_or_name.to_owned()))?;
token.trigger(source);
Ok(())
}
#[must_use]
pub fn contains_id(&self, id: &str) -> bool {
self.read_inner().by_id.contains_key(id)
}
#[must_use]
pub fn contains_name(&self, name: &str) -> bool {
self.read_inner().by_name.contains_key(name)
}
#[must_use]
pub fn len(&self) -> usize {
self.read_inner().by_id.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.read_inner().by_id.is_empty()
}
fn read_inner(&self) -> RwLockReadGuard<'_, RegistryInner> {
self.inner.read().unwrap_or_else(PoisonError::into_inner)
}
fn write_inner(&self) -> RwLockWriteGuard<'_, RegistryInner> {
self.inner.write().unwrap_or_else(PoisonError::into_inner)
}
}
impl Default for CanaryRegistry {
fn default() -> Self {
Self::new()
}
}
impl fmt::Debug for CanaryRegistry {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let inner = self.read_inner();
f.debug_struct("CanaryRegistry")
.field("tokens", &inner.by_id.len())
.finish()
}
}
#[cfg(test)]
mod tests {
use super::CanaryRegistry;
use crate::{CanaryEvent, CanaryKind, CanaryToken, Error, TriggerSource};
use std::sync::{Arc, Mutex};
fn sample_token(name: &str) -> CanaryToken {
CanaryToken::new(name, CanaryKind::Password, "canary-fake-password")
}
#[test]
fn new_registry_is_empty() {
let registry = CanaryRegistry::new();
assert!(registry.is_empty());
assert_eq!(registry.len(), 0);
}
#[test]
fn default_registry_is_empty() {
let registry = CanaryRegistry::default();
assert!(registry.is_empty());
}
#[test]
fn register_returns_id_and_stores_token() {
let registry = CanaryRegistry::new();
let token = sample_token("prod.db.password");
let id = registry
.register(token)
.expect("registration should succeed");
assert!(!id.is_empty());
assert_eq!(registry.len(), 1);
assert!(registry.contains_id(&id));
assert!(registry.contains_name("prod.db.password"));
}
#[test]
fn register_rejects_duplicate_name() {
let registry = CanaryRegistry::new();
registry
.register(sample_token("prod.db.password"))
.expect("first registration should succeed");
let result = registry.register(sample_token("prod.db.password"));
assert!(matches!(result, Err(Error::DuplicateName(_))));
}
#[test]
fn get_by_id_returns_token() {
let registry = CanaryRegistry::new();
let token = sample_token("prod.db.password");
let id = registry
.register(token)
.expect("registration should succeed");
let stored = registry.get_by_id(&id).expect("token should exist");
assert_eq!(stored.id(), id);
assert_eq!(stored.name(), "prod.db.password");
}
#[test]
fn get_by_name_returns_token() {
let registry = CanaryRegistry::new();
let token = sample_token("prod.db.password");
let id = registry
.register(token)
.expect("registration should succeed");
let stored = registry
.get_by_name("prod.db.password")
.expect("token should exist");
assert_eq!(stored.id(), id);
}
#[test]
fn get_prefers_id_then_name() {
let registry = CanaryRegistry::new();
let token = sample_token("prod.db.password");
let id = registry
.register(token)
.expect("registration should succeed");
assert!(registry.get(&id).is_some());
assert!(registry.get("prod.db.password").is_some());
assert!(registry.get("missing").is_none());
}
#[test]
fn reveal_by_id_returns_value() {
let registry = CanaryRegistry::new();
let token = sample_token("prod.db.password");
let id = registry
.register(token)
.expect("registration should succeed");
let value = registry.reveal(&id).expect("reveal should succeed");
assert_eq!(value, "canary-fake-password");
}
#[test]
fn reveal_by_name_returns_value() {
let registry = CanaryRegistry::new();
let token = sample_token("prod.db.password");
registry
.register(token)
.expect("registration should succeed");
let value = registry
.reveal("prod.db.password")
.expect("reveal should succeed");
assert_eq!(value, "canary-fake-password");
}
#[test]
fn reveal_triggers_registry_source() {
let events = Arc::new(Mutex::new(Vec::new()));
let events_clone = events.clone();
let token = sample_token("prod.db.password").on_trigger(move |event| {
events_clone
.lock()
.expect("events mutex poisoned")
.push(event.clone());
});
let registry = CanaryRegistry::new();
let id = registry
.register(token)
.expect("registration should succeed");
let value = registry.reveal(&id).expect("reveal should succeed");
assert_eq!(value, "canary-fake-password");
let events = events.lock().expect("events mutex poisoned");
assert_eq!(events.len(), 1);
assert_eq!(events[0].source, TriggerSource::Registry);
}
#[test]
fn trigger_by_id_or_name_emits_events() {
let events = Arc::new(Mutex::new(Vec::new()));
let events_clone = events.clone();
let token = sample_token("prod.db.password").on_trigger(move |event| {
events_clone
.lock()
.expect("events mutex poisoned")
.push(event.clone());
});
let registry = CanaryRegistry::new();
let id = registry
.register(token)
.expect("registration should succeed");
registry
.trigger(&id, TriggerSource::Custom("manual"))
.expect("trigger by id should succeed");
registry
.trigger("prod.db.password", TriggerSource::Registry)
.expect("trigger by name should succeed");
let events = events.lock().expect("events mutex poisoned");
assert_eq!(events.len(), 2);
assert_eq!(events[0].source, TriggerSource::Custom("manual"));
assert_eq!(events[1].source, TriggerSource::Registry);
}
#[test]
fn reveal_returns_not_found_for_missing_token() {
let registry = CanaryRegistry::new();
let result = registry.reveal("missing");
assert!(matches!(result, Err(Error::NotFound(_))));
}
#[test]
fn trigger_returns_not_found_for_missing_token() {
let registry = CanaryRegistry::new();
let result = registry.trigger("missing", TriggerSource::Registry);
assert!(matches!(result, Err(Error::NotFound(_))));
}
#[test]
fn register_shared_allows_external_access() {
let events = Arc::new(Mutex::new(Vec::new()));
let events_clone = events.clone();
let token = Arc::new(sample_token("shared.token").on_trigger(move |event| {
events_clone
.lock()
.expect("events mutex poisoned")
.push(event.clone());
}));
let registry = CanaryRegistry::new();
let id = registry
.register_shared(token.clone())
.expect("registration should succeed");
let direct_value = token.reveal();
let registry_value = registry.reveal(&id).expect("reveal should succeed");
assert_eq!(direct_value, "canary-fake-password");
assert_eq!(registry_value, "canary-fake-password");
let events = events.lock().expect("events mutex poisoned");
assert_eq!(events.len(), 2);
assert_eq!(events[0].source, TriggerSource::Reveal);
assert_eq!(events[1].source, TriggerSource::Registry);
}
#[test]
fn registry_is_send_and_sync() {
fn assert_send_sync<T: Send + Sync>() {}
assert_send_sync::<CanaryRegistry>();
}
#[test]
fn debug_shows_token_count_and_redacts_values() {
let registry = CanaryRegistry::new();
registry
.register(sample_token("prod.db.password"))
.expect("registration should succeed");
let debug = format!("{registry:?}");
assert!(debug.contains("CanaryRegistry"));
assert!(debug.contains("tokens"));
assert!(!debug.contains("canary-fake-password"));
}
#[test]
fn events_do_not_contain_canary_value() {
let events = Arc::new(Mutex::new(Vec::new()));
let events_clone = events.clone();
let token = sample_token("prod.db.password").on_trigger(move |event| {
events_clone
.lock()
.expect("events mutex poisoned")
.push(event.clone());
});
let registry = CanaryRegistry::new();
let id = registry
.register(token)
.expect("registration should succeed");
let value = registry.reveal(&id).expect("reveal should succeed");
let events = events.lock().expect("events mutex poisoned");
let event: &CanaryEvent = &events[0];
let event_debug = format!("{event:?}");
let event_display = event.to_string();
assert_eq!(value, "canary-fake-password");
assert!(!event_debug.contains("canary-fake-password"));
assert!(!event_display.contains("canary-fake-password"));
}
}