use super::*;
use futures_util::StreamExt;
use shep_core::protocol::{
BusEvent, Envelope, HelloAck, ProcessInfo, Request, Response, RpcErrorCode, codec, decode_frame,
};
use shep_core::transport::Listener;
use std::collections::VecDeque;
use std::path::PathBuf;
use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::time::Duration;
use tokio::sync::mpsc;
use tokio::task::JoinHandle;
use tokio_util::codec::Framed;
pub(super) const SCRIPT_CHANNEL_CAPACITY: usize = 8;
pub(super) enum ScriptCommand {
ReplyErr(RpcErrorCode, String),
EventThenReply,
ArmOutOfOrder,
PushEvent(Box<BusEvent>),
Close,
CloseAfterSubscribe,
}
pub(super) enum OutOfOrder {
Idle,
Armed,
Buffered(Envelope),
}
#[derive(Debug)]
pub struct FakeDaemon {
pub(super) script: mpsc::Sender<ScriptCommand>,
pub(super) armed_list: Arc<Mutex<Option<Vec<ProcessInfo>>>>,
pub(super) armed_list_sequence: Arc<Mutex<VecDeque<Vec<ProcessInfo>>>>,
pub(super) armed_describe: Arc<Mutex<Option<Vec<ProcessInfo>>>>,
pub(super) armed_reply_then_event: Arc<Mutex<Option<(Response, BusEvent)>>>,
pub(super) armed_shutdown_then_unlink: Arc<Mutex<Option<Duration>>>,
pub(super) armed_shutdown_never_unlink: Arc<Mutex<Option<()>>>,
pub(super) list_flock_count: Arc<AtomicU64>,
pub(super) task: JoinHandle<()>,
}
#[allow(clippy::too_many_arguments)]
pub(super) async fn serve_scripted(
mut listener: Listener,
socket_path: PathBuf,
ack: HelloAck,
mut script: mpsc::Receiver<ScriptCommand>,
armed_list: Arc<Mutex<Option<Vec<ProcessInfo>>>>,
armed_list_sequence: Arc<Mutex<VecDeque<Vec<ProcessInfo>>>>,
armed_describe: Arc<Mutex<Option<Vec<ProcessInfo>>>>,
armed_reply_then_event: Arc<Mutex<Option<(Response, BusEvent)>>>,
armed_shutdown_then_unlink: Arc<Mutex<Option<Duration>>>,
armed_shutdown_never_unlink: Arc<Mutex<Option<()>>>,
list_flock_count: Arc<AtomicU64>,
) {
let stream = listener.accept().await.unwrap();
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, ack).await;
let mut armed_err: Option<(RpcErrorCode, String)> = None;
let mut armed_event_then_reply = false;
let mut out_of_order = OutOfOrder::Idle;
let mut subscribed = false;
let mut pending_events: Vec<BusEvent> = Vec::new();
let mut close_after_subscribe = false;
loop {
tokio::select! {
command = script.recv() => {
match command {
Some(ScriptCommand::ReplyErr(code, message)) => armed_err = Some((code, message)),
Some(ScriptCommand::EventThenReply) => armed_event_then_reply = true,
Some(ScriptCommand::ArmOutOfOrder) => out_of_order = OutOfOrder::Armed,
Some(ScriptCommand::PushEvent(event)) => {
if subscribed {
write_event(&mut frames, *event).await;
} else {
pending_events.push(*event);
}
}
Some(ScriptCommand::CloseAfterSubscribe) => {
close_after_subscribe = true;
if subscribed {
break;
}
}
Some(ScriptCommand::Close) | None => break,
}
}
frame = frames.next() => {
let Some(Ok(frame)) = frame else { break };
let envelope: Envelope = decode_frame(&frame).unwrap();
match std::mem::replace(&mut out_of_order, OutOfOrder::Idle) {
OutOfOrder::Armed => {
out_of_order = OutOfOrder::Buffered(envelope);
}
OutOfOrder::Buffered(first) => {
let (list_env, other_env) = if matches!(first.body, Request::ListFlock) {
(first, envelope)
} else {
(envelope, first)
};
write_reply(&mut frames, list_env.id, Response::Flock(Vec::new())).await;
write_reply(&mut frames, other_env.id, Response::Pong).await;
}
OutOfOrder::Idle => {
let reply_then_event = armed_reply_then_event.lock().unwrap().take();
let shutdown_then_unlink =
armed_shutdown_then_unlink.lock().unwrap().take();
let shutdown_never_unlink =
armed_shutdown_never_unlink.lock().unwrap().take();
if let Some((reply, event)) = reply_then_event {
write_reply(&mut frames, envelope.id, reply).await;
write_event(&mut frames, event).await;
subscribed = true;
} else if let Some((code, message)) = armed_err.take() {
write_err(&mut frames, envelope.id, code, message).await;
} else if armed_event_then_reply {
armed_event_then_reply = false;
send_sample_event(&mut frames).await;
write_reply(&mut frames, envelope.id, Response::Pong).await;
} else if let Some(after) = shutdown_then_unlink {
write_reply(&mut frames, envelope.id, Response::ShuttingDown).await;
tokio::time::sleep(after).await;
let _ = std::fs::remove_file(&socket_path);
} else if shutdown_never_unlink.is_some() {
write_reply(&mut frames, envelope.id, Response::ShuttingDown).await;
} else if matches!(envelope.body, Request::Subscribe { .. }) {
write_reply(&mut frames, envelope.id, Response::Subscribed).await;
subscribed = true;
for event in pending_events.drain(..) {
write_event(&mut frames, event).await;
}
if close_after_subscribe {
break;
}
} else {
let response = if matches!(envelope.body, Request::ListFlock) {
list_flock_count.fetch_add(1, Ordering::SeqCst);
let next = armed_list_sequence.lock().unwrap().pop_front();
Response::Flock(next.unwrap_or_else(|| {
armed_list.lock().unwrap().take().unwrap_or_default()
}))
} else if matches!(envelope.body, Request::Describe { .. }) {
Response::Described(
armed_describe.lock().unwrap().take().unwrap_or_default(),
)
} else {
Response::Pong
};
write_reply(&mut frames, envelope.id, response).await;
}
}
}
}
}
}
}
impl FakeDaemon {
pub fn reply_to_list(&self, flock: Vec<ProcessInfo>) {
*self.armed_list.lock().unwrap() = Some(flock);
}
pub fn reply_to_list_sequence(&self, responses: Vec<Vec<ProcessInfo>>) {
*self.armed_list_sequence.lock().unwrap() = responses.into();
}
pub fn reply_to_describe(&self, procs: Vec<ProcessInfo>) {
*self.armed_describe.lock().unwrap() = Some(procs);
}
#[must_use]
pub fn list_flock_count(&self) -> u64 {
self.list_flock_count.load(Ordering::SeqCst)
}
pub fn queue_reply_then_event(&self, reply: Response, event: BusEvent) {
*self.armed_reply_then_event.lock().unwrap() = Some((reply, event));
}
pub fn reply_shutting_down_then_unlink_after(&self, after: Duration) {
*self.armed_shutdown_then_unlink.lock().unwrap() = Some(after);
}
pub fn reply_shutting_down_and_never_unlink(&self) {
*self.armed_shutdown_never_unlink.lock().unwrap() = Some(());
}
pub async fn push(&self, event: BusEvent) {
let _ = self
.script
.send(ScriptCommand::PushEvent(Box::new(event)))
.await;
}
pub async fn overrun_by(&self, n: usize) {
for i in 0..(crate::actor::EVENT_CHANNEL_CAPACITY + n) {
self.push(BusEvent::LogOut {
id: 1,
line: i.to_string(),
})
.await;
}
}
pub async fn close(self) {
let _ = self.script.send(ScriptCommand::Close).await;
self.task.await.unwrap();
}
pub async fn close_after_subscribe(&self) {
let _ = self.script.send(ScriptCommand::CloseAfterSubscribe).await;
}
}