use std::sync::Arc;
use async_trait::async_trait;
use krot_proto::PubKey;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PeerLookupOutcome {
NotFound,
Found(PubKey),
Unavailable,
}
#[async_trait]
pub trait PeerLabelLookup: Send + Sync + std::fmt::Debug {
async fn find_owner(&self, peer_apex: &str, label: &str) -> PeerLookupOutcome;
}
#[derive(Debug, Clone, Copy, Default)]
pub struct NoOpPeerLookup;
#[async_trait]
impl PeerLabelLookup for NoOpPeerLookup {
async fn find_owner(&self, _peer_apex: &str, _label: &str) -> PeerLookupOutcome {
PeerLookupOutcome::NotFound
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CollisionCheck {
Clear { matched_peers: Vec<String> },
Conflict { first_conflict: String },
}
pub async fn check_collision(
lookup: &Arc<dyn PeerLabelLookup>,
peers: &[String],
label: &str,
self_pubkey: &PubKey,
) -> CollisionCheck {
let mut matched_peers = Vec::new();
for peer in peers {
match lookup.find_owner(peer, label).await {
PeerLookupOutcome::NotFound | PeerLookupOutcome::Unavailable => {}
PeerLookupOutcome::Found(owner) => {
if owner == *self_pubkey {
matched_peers.push(peer.clone());
} else {
return CollisionCheck::Conflict {
first_conflict: peer.clone(),
};
}
}
}
}
CollisionCheck::Clear { matched_peers }
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::HashMap;
use std::sync::Mutex;
#[derive(Debug, Default)]
struct MockLookup {
by_peer_label: Mutex<HashMap<(String, String), PeerLookupOutcome>>,
}
impl MockLookup {
fn insert(&self, peer: &str, label: &str, outcome: PeerLookupOutcome) {
self.by_peer_label
.lock()
.unwrap()
.insert((peer.into(), label.into()), outcome);
}
}
#[async_trait]
impl PeerLabelLookup for MockLookup {
async fn find_owner(&self, peer: &str, label: &str) -> PeerLookupOutcome {
self.by_peer_label
.lock()
.unwrap()
.get(&(peer.into(), label.into()))
.copied()
.unwrap_or(PeerLookupOutcome::NotFound)
}
}
#[tokio::test]
async fn no_op_always_clear() {
let lookup: Arc<dyn PeerLabelLookup> = Arc::new(NoOpPeerLookup);
let peers = vec!["a".into(), "b".into()];
let out = check_collision(&lookup, &peers, "svc", &PubKey([1; 32])).await;
assert_eq!(
out,
CollisionCheck::Clear {
matched_peers: vec![]
}
);
}
#[tokio::test]
async fn conflict_on_different_owner() {
let mock = Arc::new(MockLookup::default());
mock.insert(
"a.example",
"svc",
PeerLookupOutcome::Found(PubKey([9; 32])),
);
let lookup: Arc<dyn PeerLabelLookup> = mock;
let peers = vec!["a.example".into()];
let out = check_collision(&lookup, &peers, "svc", &PubKey([1; 32])).await;
assert_eq!(
out,
CollisionCheck::Conflict {
first_conflict: "a.example".into()
}
);
}
#[tokio::test]
async fn same_owner_is_additional_destination() {
let self_pk = PubKey([1; 32]);
let mock = Arc::new(MockLookup::default());
mock.insert("a.example", "svc", PeerLookupOutcome::Found(self_pk));
mock.insert("b.example", "svc", PeerLookupOutcome::Found(self_pk));
let lookup: Arc<dyn PeerLabelLookup> = mock;
let peers = vec!["a.example".into(), "b.example".into()];
let out = check_collision(&lookup, &peers, "svc", &self_pk).await;
assert_eq!(
out,
CollisionCheck::Clear {
matched_peers: vec!["a.example".into(), "b.example".into()]
}
);
}
#[tokio::test]
async fn unavailable_is_fail_open() {
let mock = Arc::new(MockLookup::default());
mock.insert("a.example", "svc", PeerLookupOutcome::Unavailable);
let lookup: Arc<dyn PeerLabelLookup> = mock;
let peers = vec!["a.example".into()];
let out = check_collision(&lookup, &peers, "svc", &PubKey([1; 32])).await;
assert_eq!(
out,
CollisionCheck::Clear {
matched_peers: vec![]
}
);
}
#[tokio::test]
async fn any_conflict_short_circuits() {
let self_pk = PubKey([1; 32]);
let other = PubKey([9; 32]);
let mock = Arc::new(MockLookup::default());
mock.insert("a.example", "svc", PeerLookupOutcome::Found(self_pk));
mock.insert("b.example", "svc", PeerLookupOutcome::Found(other));
mock.insert("c.example", "svc", PeerLookupOutcome::Found(other));
let lookup: Arc<dyn PeerLabelLookup> = mock;
let peers = vec!["a.example".into(), "b.example".into(), "c.example".into()];
let out = check_collision(&lookup, &peers, "svc", &self_pk).await;
assert_eq!(
out,
CollisionCheck::Conflict {
first_conflict: "b.example".into()
}
);
}
}