use super::*;
use futures_util::{SinkExt, StreamExt};
use shep_core::protocol::{
Envelope, Hello, HelloAck, HelloReply, ProcessInfo, Request, Response, RpcError, codec,
decode_frame, encode_frame,
};
use std::path::Path;
use std::sync::atomic::{AtomicBool, AtomicU32, Ordering};
use std::sync::{Arc, Mutex};
use tokio::sync::mpsc;
use tokio::task::JoinHandle;
use tokio_util::codec::Framed;
#[derive(Debug, Clone)]
pub enum Handshake {
Accept(HelloAck),
Refuse(RpcError),
Drop,
}
#[derive(Debug)]
pub struct Handovers {
cut: mpsc::Sender<()>,
cut_on_next_request: Arc<AtomicBool>,
accepted: Arc<AtomicU32>,
hellos: Arc<Mutex<Vec<Hello>>>,
envelopes: Arc<Mutex<Vec<(u32, Envelope)>>>,
armed_list: Arc<Mutex<Vec<ProcessInfo>>>,
armed_dog_section: Arc<Mutex<String>>,
armed_subscribe_err: Arc<Mutex<Option<RpcError>>>,
task: JoinHandle<()>,
}
impl Drop for Handovers {
fn drop(&mut self) {
self.task.abort();
}
}
#[must_use]
pub fn fake_daemon_across_handovers(path: &Path, handshakes: Vec<Handshake>) -> Handovers {
assert!(
!handshakes.is_empty(),
"a handover fixture needs at least one generation"
);
let mut listener = bind(path);
let (cut_tx, mut cut_rx) = mpsc::channel(SCRIPT_CHANNEL_CAPACITY);
let cut_on_next_request = Arc::new(AtomicBool::new(false));
let accepted = Arc::new(AtomicU32::new(0));
let hellos: Arc<Mutex<Vec<Hello>>> = Arc::new(Mutex::new(Vec::new()));
let envelopes: Arc<Mutex<Vec<(u32, Envelope)>>> = Arc::new(Mutex::new(Vec::new()));
let armed_list: Arc<Mutex<Vec<ProcessInfo>>> = Arc::new(Mutex::new(Vec::new()));
let armed_dog_section: Arc<Mutex<String>> = Arc::new(Mutex::new(String::new()));
let armed_subscribe_err: Arc<Mutex<Option<RpcError>>> = Arc::new(Mutex::new(None));
let task = tokio::spawn({
let cut_on_next_request = Arc::clone(&cut_on_next_request);
let accepted = Arc::clone(&accepted);
let hellos = Arc::clone(&hellos);
let envelopes = Arc::clone(&envelopes);
let armed_list = Arc::clone(&armed_list);
let armed_dog_section = Arc::clone(&armed_dog_section);
let armed_subscribe_err = Arc::clone(&armed_subscribe_err);
async move {
let mut generation: u32 = 0;
while let Ok(stream) = listener.accept().await {
generation += 1;
accepted.fetch_add(1, Ordering::SeqCst);
let index = usize::try_from(generation - 1).unwrap_or(usize::MAX);
let script = handshakes
.get(index)
.unwrap_or_else(|| handshakes.last().expect("non-empty, asserted above"))
.clone();
let mut frames = Framed::new(stream, codec());
match script {
Handshake::Drop => continue,
Handshake::Refuse(err) => {
if let Some(Ok(first)) = frames.next().await {
hellos.lock().unwrap().push(decode_frame(&first).unwrap());
}
let reply: HelloReply = Err(err);
let _ = frames.send(encode_frame(&reply).unwrap()).await;
continue;
}
Handshake::Accept(ack) => {
let hello = handshake(&mut frames, ack).await;
hellos.lock().unwrap().push(hello);
}
}
loop {
tokio::select! {
frame = frames.next() => {
let Some(Ok(bytes)) = frame else { break };
let envelope: Envelope = decode_frame(&bytes).unwrap();
let id = envelope.id;
let body = envelope.body.clone();
envelopes.lock().unwrap().push((generation, envelope));
if cut_on_next_request.swap(false, Ordering::SeqCst) {
break;
}
let refusal = if matches!(body, Request::Subscribe { .. }) {
armed_subscribe_err.lock().unwrap().take()
} else {
None
};
if let Some(refusal) = refusal {
write_err(&mut frames, id, refusal.code, refusal.message).await;
continue;
}
let response = match body {
Request::ListFlock => {
Response::Flock(armed_list.lock().unwrap().clone())
}
Request::Subscribe { .. } => Response::Subscribed,
Request::DogConfig { .. } => Response::DogSection {
toml: armed_dog_section.lock().unwrap().clone().into(),
},
_ => Response::Pong,
};
write_reply(&mut frames, id, response).await;
}
_ = cut_rx.recv() => break,
}
}
}
}
});
Handovers {
cut: cut_tx,
cut_on_next_request,
accepted,
hellos,
envelopes,
armed_list,
armed_dog_section,
armed_subscribe_err,
task,
}
}
impl Handovers {
pub async fn cut(&self) {
let _ = self.cut.send(()).await;
}
pub fn cut_on_next_request(&self) {
self.cut_on_next_request.store(true, Ordering::SeqCst);
}
#[must_use]
pub fn accepted(&self) -> u32 {
self.accepted.load(Ordering::SeqCst)
}
#[must_use]
pub fn hellos(&self) -> Vec<Hello> {
self.hellos.lock().unwrap().clone()
}
#[must_use]
pub fn envelopes(&self) -> Vec<(u32, Envelope)> {
self.envelopes.lock().unwrap().clone()
}
pub fn reply_to_list(&self, flock: Vec<ProcessInfo>) {
*self.armed_list.lock().unwrap() = flock;
}
pub fn reply_to_dog_config(&self, section: &str) {
*self.armed_dog_section.lock().unwrap() = section.to_owned();
}
pub fn refuse_next_subscribe(&self, refusal: RpcError) {
*self.armed_subscribe_err.lock().unwrap() = Some(refusal);
}
}