use std::collections::{HashMap, HashSet};
use std::sync::Arc;
use std::time::Duration;
use grain_id::GrainId;
use sapphire_framework_session::LiveSession;
use sapphire_sync::{PathUpdate, Replica};
use tokio::sync::{Mutex, broadcast};
pub const DIAL_INTERVAL: Duration = Duration::from_secs(5);
pub const OPEN_TIMEOUT: Duration = Duration::from_secs(10);
pub const DIAL_BACKOFF_MAX: Duration = Duration::from_secs(5 * 60);
pub(crate) fn dial_backoff(attempt: u32) -> Duration {
let secs = 1u64 << attempt.min(9);
Duration::from_secs(secs).min(DIAL_BACKOFF_MAX)
}
pub(crate) struct LivePeers {
me: GrainId,
sessions: Mutex<HashMap<GrainId, Arc<LiveSession>>>,
dialing: Mutex<HashSet<GrainId>>,
}
impl LivePeers {
pub(crate) fn new(me: GrainId) -> LivePeers {
LivePeers {
me,
sessions: Mutex::new(HashMap::new()),
dialing: Mutex::new(HashSet::new()),
}
}
pub(crate) async fn begin_dial(&self, device: GrainId) -> bool {
self.dialing.lock().await.insert(device)
}
pub(crate) async fn end_dial(&self, device: GrainId) {
self.dialing.lock().await.remove(&device);
}
pub(crate) async fn fan_out(&self, updates: &[PathUpdate], from: Option<GrainId>) {
if updates.is_empty() {
return;
}
let mut sessions = self.sessions.lock().await;
sessions.retain(|_, session| session.is_open());
for (device, session) in sessions.iter() {
if Some(device) == from.as_ref() {
continue;
}
let seen: Vec<_> = updates.iter().map(|u| u.seen.clone()).collect();
if seen.iter().all(|v| session.peer_vv().covers(v)) {
continue;
}
if let Err(err) = session.push(updates.to_vec()).await {
tracing::debug!(%device, "a live push failed: {err}");
}
}
}
pub(crate) async fn insert(
&self,
device: GrainId,
session: LiveSession,
outbound: bool,
) -> Option<broadcast::Receiver<Vec<PathUpdate>>> {
if (self.me < device) != outbound {
return None;
}
let updates = session.updates();
self.sessions.lock().await.insert(device, Arc::new(session));
Some(updates)
}
pub(crate) async fn catch_up(&self, device: GrainId, replica: &Mutex<Replica>) {
let Some(session) = self.sessions.lock().await.get(&device).cloned() else {
return;
};
let delta = match replica.lock().await.delta_for(&session.peer_vv()) {
Ok(delta) => delta,
Err(err) => {
tracing::debug!(%device, "no catch-up for a new live session: {err}");
return;
}
};
if delta.is_empty() {
return;
}
if let Err(err) = session.push(delta).await {
tracing::debug!(%device, "a live push failed: {err}");
}
}
pub(crate) async fn devices(&self) -> Vec<GrainId> {
let sessions = self.sessions.lock().await;
sessions
.iter()
.filter(|(_, session)| session.is_open())
.map(|(device, _)| *device)
.collect()
}
pub(crate) async fn acknowledging(&self) -> usize {
self.sessions
.lock()
.await
.values()
.filter(|session| session.is_open() && session.peer_acknowledges())
.count()
}
pub(crate) async fn has(&self, device: &GrainId) -> bool {
self.sessions
.lock()
.await
.get(device)
.is_some_and(|session| session.is_open())
}
pub(crate) async fn drop_connections(&self) {
self.sessions.lock().await.clear();
}
pub(crate) async fn retain(&self, keep: impl Fn(&GrainId) -> bool) {
self.sessions.lock().await.retain(|device, _| keep(device));
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_dial_backoff_doubles_and_caps_at_five_minutes() {
assert_eq!(dial_backoff(0), Duration::from_secs(1));
assert_eq!(dial_backoff(1), Duration::from_secs(2));
assert_eq!(dial_backoff(2), Duration::from_secs(4));
assert_eq!(
dial_backoff(3),
Duration::from_secs(8),
"each failure doubles the wait"
);
assert_eq!(
dial_backoff(4),
Duration::from_secs(16),
"each failure doubles the wait"
);
assert_eq!(
dial_backoff(9),
DIAL_BACKOFF_MAX,
"doubling reaches the cap at nine failures"
);
assert_eq!(
dial_backoff(40),
DIAL_BACKOFF_MAX,
"the cap holds however many failures"
);
}
}