use grain_id::GrainId;
use sapphire_backend::protocol as proto;
use sapphire_bridge_api::WorkspaceRoles;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum Link {
Dial,
Await,
Skip,
}
pub(crate) fn link(me: GrainId, peer: GrainId, roles: Option<&WorkspaceRoles>) -> Link {
let hub = |d: GrainId| roles.is_some_and(|r| r.primary == Some(d) || r.secondary == Some(d));
let star = roles.is_some_and(|r| r.primary.is_some());
if star && !hub(me) && !hub(peer) {
Link::Skip
} else if me < peer {
Link::Dial
} else {
Link::Await
}
}
pub(crate) fn may_close_skipped(
me: GrainId,
roles: Option<&WorkspaceRoles>,
open: &[GrainId],
) -> bool {
let Some(r) = roles else {
return true;
};
let hub = |d: &GrainId| r.primary == Some(*d) || r.secondary == Some(*d);
hub(&me) || open.iter().any(hub)
}
pub(crate) fn topology(roles: Option<&WorkspaceRoles>) -> proto::Topology {
match roles.and_then(|r| r.primary.map(|d| (d, r.secondary))) {
Some((primary, secondary)) => proto::Topology::Star { primary, secondary },
None => proto::Topology::Mesh,
}
}
#[cfg(test)]
mod tests {
use super::*;
fn sorted(n: usize) -> Vec<GrainId> {
let mut v: Vec<GrainId> = (0..n).map(|_| GrainId::random()).collect();
v.sort();
v
}
fn roles(ws: GrainId, d: Option<GrainId>, b: Option<GrainId>) -> WorkspaceRoles {
WorkspaceRoles {
workspace_id: ws,
primary: d,
secondary: b,
}
}
#[test]
fn no_roles_is_the_mesh() {
let id = sorted(2);
assert_eq!(link(id[0], id[1], None), Link::Dial);
assert_eq!(link(id[1], id[0], None), Link::Await);
let empty = roles(GrainId::random(), None, None);
assert_eq!(link(id[0], id[1], Some(&empty)), Link::Dial);
}
#[test]
fn an_entry_with_no_roles_is_the_mesh() {
let id = sorted(2);
let empty = roles(GrainId::random(), None, None);
assert_eq!(link(id[0], id[1], Some(&empty)), Link::Dial);
assert_eq!(link(id[1], id[0], Some(&empty)), Link::Await);
assert_eq!(topology(Some(&empty)), proto::Topology::Mesh);
}
#[test]
fn skipped_sessions_close_only_with_a_hub_session_in_hand() {
let id = sorted(4);
let r = roles(GrainId::random(), Some(id[0]), Some(id[1]));
assert!(may_close_skipped(id[0], Some(&r), &[]), "a hub");
assert!(!may_close_skipped(id[2], Some(&r), &[id[3]]));
assert!(may_close_skipped(id[2], Some(&r), &[id[3], id[1]]));
assert!(may_close_skipped(id[2], None, &[]), "the mesh skips no one");
}
#[test]
fn a_handover_with_stale_views_never_strands_a_host() {
use std::collections::{BTreeMap, BTreeSet};
let id = sorted(4);
let (b, x, y, d) = (id[0], id[1], id[2], id[3]);
let ws = GrainId::random();
let view = |p, s| roles(ws, Some(p), s);
type Pair = (GrainId, GrainId);
let pair = |a: GrainId, c: GrainId| (a.min(c), a.max(c));
let mut sessions: BTreeSet<Pair> =
[pair(x, d), pair(y, d), pair(b, d), pair(x, b), pair(y, b)]
.into_iter()
.collect();
let steps: Vec<BTreeMap<GrainId, WorkspaceRoles>> = vec![
[
(b, view(b, None)),
(x, view(d, Some(b))),
(y, view(d, Some(b))),
]
.into(),
[
(b, view(b, None)),
(x, view(d, Some(y))),
(y, view(d, Some(b))),
]
.into(),
[
(b, view(b, Some(y))),
(x, view(d, Some(y))),
(y, view(d, Some(y))),
]
.into(),
[
(b, view(b, Some(y))),
(x, view(b, Some(y))),
(y, view(b, Some(y))),
]
.into(),
];
sessions.retain(|(p, q)| *p != d && *q != d);
for (n, views) in steps.iter().enumerate() {
let open = |h: GrainId, s: &BTreeSet<Pair>| -> Vec<GrainId> {
s.iter()
.filter_map(|&(p, q)| (p == h).then_some(q).or((q == h).then_some(p)))
.collect()
};
for (&me, r) in views {
let mine = open(me, &sessions);
if may_close_skipped(me, Some(r), &mine) {
sessions.retain(|&(p, q)| {
let other = if p == me {
q
} else if q == me {
p
} else {
return true;
};
link(me, other, Some(r)) != Link::Skip
});
}
}
for (&me, r) in views {
for (&peer, theirs) in views {
if peer != me
&& link(me, peer, Some(r)) == Link::Dial
&& link(peer, me, Some(theirs)) != Link::Skip
{
sessions.insert(pair(me, peer));
}
}
}
for &h in views.keys() {
assert!(
!open(h, &sessions).is_empty(),
"step {n}: host {h} has no session; sessions {sessions:?}"
);
}
}
}
#[test]
fn two_non_hubs_skip_each_other() {
let id = sorted(4); let r = roles(GrainId::random(), Some(id[0]), Some(id[1]));
assert_eq!(link(id[2], id[3], Some(&r)), Link::Skip);
assert_eq!(link(id[3], id[2], Some(&r)), Link::Skip);
}
#[test]
fn a_hub_accepts_everyone() {
let id = sorted(4);
let r = roles(GrainId::random(), Some(id[3]), Some(id[2]));
assert_eq!(link(id[0], id[3], Some(&r)), Link::Dial);
assert_eq!(link(id[3], id[0], Some(&r)), Link::Await);
assert_eq!(link(id[2], id[3], Some(&r)), Link::Dial);
}
#[test]
fn an_old_server_that_dials_a_hub_is_kept() {
let id = sorted(3);
let r = roles(GrainId::random(), Some(id[2]), None);
assert_ne!(link(id[2], id[0], Some(&r)), Link::Skip);
}
#[test]
fn secondary_only_roles_are_the_mesh() {
let id = sorted(3);
let r = roles(GrainId::random(), None, Some(id[2]));
assert_eq!(link(id[0], id[1], Some(&r)), Link::Dial);
assert_eq!(link(id[1], id[0], Some(&r)), Link::Await);
assert_eq!(topology(Some(&r)), proto::Topology::Mesh);
}
#[test]
fn link_covers_every_role_pair_in_both_id_orders() {
let perms: Vec<[usize; 4]> = {
let mut out = Vec::new();
for a in 0..4 {
for b in 0..4 {
for c in 0..4 {
for d in 0..4 {
let p = [a, b, c, d];
let mut s = p;
s.sort();
if s == [0, 1, 2, 3] {
out.push(p);
}
}
}
}
}
out
};
assert_eq!(perms.len(), 24);
let ids = sorted(4);
let mut seen = Vec::new();
for perm in perms {
let id = |slot: usize| ids[perm[slot]];
let r = roles(GrainId::random(), Some(id(0)), Some(id(1)));
for me in 0..4 {
for peer in 0..4 {
if me == peer {
continue;
}
let expected = if me >= 2 && peer >= 2 {
Link::Skip
} else if id(me) < id(peer) {
Link::Dial
} else {
Link::Await
};
assert_eq!(
link(id(me), id(peer), Some(&r)),
expected,
"me slot {me}, peer slot {peer}, ranks {perm:?}"
);
seen.push((me.min(2), peer.min(2), expected));
}
}
}
for me in 0..3 {
for peer in 0..3 {
if me == peer && me < 2 {
continue;
}
if me == 2 && peer == 2 {
assert!(seen.contains(&(2, 2, Link::Skip)));
} else {
assert!(
seen.contains(&(me, peer, Link::Dial)),
"{me} -> {peer} Dial"
);
assert!(
seen.contains(&(me, peer, Link::Await)),
"{me} -> {peer} Await"
);
}
}
}
}
#[test]
fn named_cases_against_the_hubs() {
let id = sorted(4);
let r = roles(GrainId::random(), Some(id[3]), Some(id[1]));
assert_eq!(link(id[0], id[1], Some(&r)), Link::Dial);
assert_eq!(link(id[2], id[1], Some(&r)), Link::Await);
let r = roles(GrainId::random(), Some(id[0]), Some(id[1]));
assert_eq!(link(id[3], id[0], Some(&r)), Link::Await);
assert_eq!(link(id[0], id[3], Some(&r)), Link::Dial);
}
#[test]
fn topology_is_star_only_with_a_primary_device() {
let d = GrainId::random();
assert_eq!(topology(None), proto::Topology::Mesh);
assert_eq!(
topology(Some(&roles(GrainId::random(), Some(d), None))),
proto::Topology::Star {
primary: d,
secondary: None
}
);
}
}