use std::collections::HashSet;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use grain_id::GrainId;
use sapphire_sync::{ContentHash, PathUpdate, Replica, VersionVector};
use tokio::io::{AsyncRead, AsyncWrite};
use tokio::sync::{broadcast, mpsc};
use tokio::task::JoinHandle;
use crate::error::{Error, Result};
use crate::frame::{Frame, read_frame};
use crate::message::Message;
use crate::session::{self, Exchange, Out, SessionOutcome, Stop, send};
const LIVE_QUEUE: usize = 64;
pub struct LiveSession {
out: mpsc::Sender<Out>,
updates: broadcast::Sender<Vec<PathUpdate>>,
peer_vv: Arc<Mutex<VersionVector>>,
open: Arc<AtomicBool>,
reader: JoinHandle<()>,
}
impl LiveSession {
pub async fn push(&self, updates: Vec<PathUpdate>) -> Result<()> {
if !self.is_open() {
return Err(Error::Protocol("the session is closed".to_owned()));
}
self.out
.send(Out::Control(Message::Live(updates)))
.await
.map_err(|_| Error::Protocol("the session is closed".to_owned()))
}
pub fn updates(&self) -> broadcast::Receiver<Vec<PathUpdate>> {
self.updates.subscribe()
}
pub fn peer_vv(&self) -> VersionVector {
self.peer_vv.lock().expect("peer vv").clone()
}
pub fn is_open(&self) -> bool {
self.open.load(Ordering::Relaxed)
}
pub fn close(self) {
drop(self);
}
}
impl Drop for LiveSession {
fn drop(&mut self) {
self.open.store(false, Ordering::Relaxed);
self.reader.abort();
}
}
struct Pending {
batch: Vec<PathUpdate>,
outstanding: HashSet<ContentHash>,
}
pub async fn open_live_session<S>(
stream: S,
replica: Arc<tokio::sync::Mutex<Replica>>,
workspace_id: GrainId,
) -> Result<(SessionOutcome, LiveSession)>
where
S: AsyncRead + AsyncWrite + Send + Unpin + 'static,
{
let exchange = session::initial_exchange(stream, &replica, workspace_id).await?;
if !matches!(&exchange.stop, Stop::Complete) {
let why = match &exchange.stop {
Stop::Gone => Error::Protocol("the peer left before the exchange finished".to_owned()),
Stop::Refused(why) => Error::Refused(why.clone()),
Stop::Protocol(why) => Error::Protocol(why.clone()),
Stop::Complete => unreachable!("checked above"),
};
exchange.queued.abort();
session::abort(exchange.out, exchange.writer);
return Err(why);
}
let Exchange {
reader,
out,
writer: _,
queued,
peer_vv,
mut received,
outcome,
stop: _,
} = exchange;
let _ = queued.await;
let outcome = {
let mut locked = replica.lock().await;
session::materialise(&mut locked, &received, &peer_vv, outcome)?
};
let peer_vv = Arc::new(Mutex::new(peer_vv));
let open = Arc::new(AtomicBool::new(true));
let (updates, _) = broadcast::channel(LIVE_QUEUE);
let reader_task = {
let replica = Arc::clone(&replica);
let peer_vv = Arc::clone(&peer_vv);
let open = Arc::clone(&open);
let updates = updates.clone();
let out = out.clone();
let mut reader = reader;
let mut wanted: HashSet<ContentHash> = HashSet::new();
let mut pending: Vec<Pending> = Vec::new();
tokio::spawn(async move {
loop {
let mut wrote_content = false;
match read_frame(&mut reader).await {
Ok(Some(Frame::Control(Message::Live(batch)))) => {
{
let mut known = peer_vv.lock().expect("peer vv");
for update in &batch {
known.merge(&update.seen);
}
}
let missing = {
let mut locked = replica.lock().await;
if let Err(err) = locked.apply(&batch, &received) {
tracing::warn!("a live batch was not applied: {err}");
break;
}
match session::needed(&locked, &batch, &received) {
Ok(missing) => missing,
Err(err) => {
tracing::warn!("a live batch could not be checked: {err}");
break;
}
}
};
let mut outstanding = HashSet::new();
for hash in missing {
if wanted.insert(hash)
&& send(&out, Out::Control(Message::Want(hash))).await.is_err()
{
return;
}
outstanding.insert(hash);
}
pending.push(Pending { batch, outstanding });
}
Ok(Some(Frame::Control(Message::Want(hash)))) => {
let answer = {
let locked = replica.lock().await;
match locked.read_content(&hash) {
Ok(Some(bytes)) => Out::Blob(hash, bytes),
_ => Out::Control(Message::Missing(hash)),
}
};
if send(&out, answer).await.is_err() {
break;
}
}
Ok(Some(Frame::Blob { hash, bytes })) => {
if ContentHash::of_bytes(&bytes) != hash {
tracing::warn!("content does not match {hash}");
break;
}
remember(&mut wanted, &mut pending, hash);
received.0.insert(hash, bytes);
wrote_content = true;
}
Ok(Some(Frame::Control(Message::Missing(hash)))) => {
remember(&mut wanted, &mut pending, hash);
}
Ok(Some(other)) => {
tracing::warn!("a live session got an unexpected frame: {other:?}");
break;
}
Ok(None) => break,
Err(err) => {
tracing::debug!("a live session stopped reading: {err}");
break;
}
}
if wrote_content {
let mut locked = replica.lock().await;
if let Err(err) = locked.fetch_missing(&received) {
tracing::warn!("fetched content did not settle: {err}");
break;
}
}
pending.retain(|entry| {
if entry.outstanding.is_empty() {
let _ = updates.send(entry.batch.clone());
false
} else {
true
}
});
}
open.store(false, Ordering::Relaxed);
})
};
let live = LiveSession {
out,
updates,
peer_vv,
open,
reader: reader_task,
};
Ok((outcome, live))
}
fn remember(wanted: &mut HashSet<ContentHash>, pending: &mut [Pending], hash: ContentHash) {
wanted.remove(&hash);
for entry in pending.iter_mut() {
entry.outstanding.remove(&hash);
}
}