use std::collections::VecDeque;
use std::path::{Path, PathBuf};
use std::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, Ordering};
use std::sync::{Arc, Mutex};
use std::time::Duration;
use futures_util::{SinkExt, StreamExt};
use shep_core::transport::{Listener, ServerStream};
use tokio::sync::mpsc;
use tokio::task::JoinHandle;
use tokio_util::codec::Framed;
use shep_core::protocol::{
BusEvent, DogSource, Envelope, ExitInfo, Hello, HelloAck, HelloReply, Lamb, PROTOCOL_VERSION,
ProcessEventKind, ProcessInfo, Reply, Request, Response, RpcError, RpcErrorCode, codec,
decode_frame, encode_frame,
};
use shep_core::status::ProcStatus;
use crate::{Client, ReconnectingClient};
#[must_use]
pub fn control_address(dir: &Path) -> PathBuf {
#[cfg(unix)]
{
dir.join("s.sock")
}
#[cfg(windows)]
{
let sanitized: String = dir
.to_string_lossy()
.chars()
.map(|c| if c.is_ascii_alphanumeric() { c } else { '-' })
.collect();
PathBuf::from(format!(
r"\\.\pipe\shep-test-{}-{}",
std::process::id(),
sanitized.trim_matches('-')
))
}
}
type Frames = Framed<ServerStream, tokio_util::codec::LengthDelimitedCodec>;
use crate::spawn::SpawnOptions;
pub async fn fake_daemon(path: &Path, reply: HelloReply) -> JoinHandle<Hello> {
let mut listener = Listener::bind(path).unwrap();
tokio::spawn(async move {
let stream = listener.accept().await.unwrap();
let mut frames = Framed::new(stream, codec());
let first = frames.next().await.unwrap().unwrap();
let hello: Hello = decode_frame(&first).unwrap();
frames.send(encode_frame(&reply).unwrap()).await.unwrap();
hello
})
}
pub async fn serve_one_request(
path: &Path,
ack: HelloAck,
response: Response,
) -> JoinHandle<Envelope> {
let mut listener = Listener::bind(path).unwrap();
tokio::spawn(async move {
let stream = listener.accept().await.unwrap();
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, ack).await;
let envelope = read_envelope(&mut frames).await;
write_reply(&mut frames, envelope.id, response).await;
envelope
})
}
pub fn fake_daemon_accepting_repeatedly(
path: &Path,
reply: Response,
) -> (JoinHandle<()>, Arc<AtomicU32>) {
fake_daemon_accepting_repeatedly_with_ack(path, sample_ack(), reply)
}
pub fn fake_daemon_accepting_repeatedly_with_ack(
path: &Path,
ack: HelloAck,
reply: Response,
) -> (JoinHandle<()>, Arc<AtomicU32>) {
let mut listener = Listener::bind(path).unwrap();
let served = Arc::new(AtomicU32::new(0));
let counter = Arc::clone(&served);
let handle = tokio::spawn(async move {
while let Ok(stream) = listener.accept().await {
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, ack.clone()).await;
let envelope = read_envelope(&mut frames).await;
write_reply(&mut frames, envelope.id, reply.clone()).await;
counter.fetch_add(1, Ordering::SeqCst);
}
});
(handle, served)
}
#[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>>,
task: JoinHandle<()>,
}
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();
}
}
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 = Listener::bind(path).unwrap();
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 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);
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 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,
task,
}
}
#[must_use]
pub fn sample_ack() -> HelloAck {
HelloAck {
daemon_version: "9.9.9".into(),
protocol: PROTOCOL_VERSION,
pid: 4242,
}
}
#[must_use]
pub fn sample_info() -> ProcessInfo {
ProcessInfo::builder(1, "web", ProcStatus::Online)
.pid(Some(4242))
.restarts(3)
.uptime_ms(60_000)
.fold(Some("backend".to_string()))
.out_file(Some("/home/ada/.shep/logs/web-0-out.log".to_string()))
.err_file(Some("/home/ada/.shep/logs/web-0-err.log".to_string()))
.cpu_percent(Some(12.5))
.memory_bytes(Some(48 * 1024 * 1024))
.dog(Some(DogSource::BuiltIn))
.lambs(Some(vec![Lamb::new(4243, "node")]))
.last_exit(Some(ExitInfo {
code: Some(1),
signal: None,
}))
.smit(Some("\u{25b2} main@a1b2c3".to_string()))
.build()
}
const SCRIPT_CHANNEL_CAPACITY: usize = 8;
async fn handshake(frames: &mut Frames, ack: HelloAck) -> Hello {
let first = frames.next().await.unwrap().unwrap();
let hello: Hello = decode_frame(&first).unwrap();
let reply: HelloReply = Ok(ack);
frames.send(encode_frame(&reply).unwrap()).await.unwrap();
hello
}
async fn read_envelope(frames: &mut Frames) -> Envelope {
let frame = frames.next().await.unwrap().unwrap();
decode_frame(&frame).unwrap()
}
async fn write_reply(frames: &mut Frames, id: u64, response: Response) {
let reply = Reply {
id,
result: Ok(response),
};
frames.send(encode_frame(&reply).unwrap()).await.unwrap();
}
async fn write_err(frames: &mut Frames, id: u64, code: RpcErrorCode, message: String) {
let reply = Reply {
id,
result: Err(RpcError {
code,
message,
daemon_version: None,
}),
};
frames.send(encode_frame(&reply).unwrap()).await.unwrap();
}
async fn write_event(frames: &mut Frames, event: BusEvent) {
frames.send(encode_frame(&event).unwrap()).await.unwrap();
}
async fn send_sample_event(frames: &mut Frames) {
write_event(
frames,
BusEvent::Process {
event: ProcessEventKind::Online,
info: sample_info(),
manually: false,
at_ms: 0,
},
)
.await;
}
enum ScriptCommand {
ReplyErr(RpcErrorCode, String),
EventThenReply,
ArmOutOfOrder,
PushEvent(Box<BusEvent>),
Close,
CloseAfterSubscribe,
}
enum OutOfOrder {
Idle,
Armed,
Buffered(Envelope),
}
#[derive(Debug)]
pub struct FakeDaemon {
script: mpsc::Sender<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>,
task: JoinHandle<()>,
}
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;
}
}
#[allow(clippy::too_many_arguments)]
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;
}
}
}
}
}
}
}
pub async fn fake_client_on(path: &Path) -> (Client, FakeDaemon) {
fake_client_with_ack(path, sample_ack()).await
}
pub async fn fake_client_with_ack(path: &Path, ack: HelloAck) -> (Client, FakeDaemon) {
let daemon = fake_daemon_scripted_on(path, ack);
let client = Client::connect(path).await.unwrap();
(client, daemon)
}
pub async fn fake_reconnecting_client_on(path: &Path) -> (ReconnectingClient, FakeDaemon) {
let daemon = fake_daemon_scripted_on(path, sample_ack());
let client = ReconnectingClient::connect(path).await.unwrap();
(client, daemon)
}
#[must_use]
pub fn fake_daemon_scripted_on(path: &Path, ack: HelloAck) -> FakeDaemon {
let listener = Listener::bind(path).unwrap();
let (script_tx, script_rx) = mpsc::channel(SCRIPT_CHANNEL_CAPACITY);
let armed_list = Arc::new(Mutex::new(None));
let armed_list_sequence = Arc::new(Mutex::new(VecDeque::new()));
let armed_describe = Arc::new(Mutex::new(None));
let armed_reply_then_event = Arc::new(Mutex::new(None));
let armed_shutdown_then_unlink = Arc::new(Mutex::new(None));
let armed_shutdown_never_unlink = Arc::new(Mutex::new(None));
let list_flock_count = Arc::new(AtomicU64::new(0));
let task = tokio::spawn(serve_scripted(
listener,
path.to_path_buf(),
ack,
script_rx,
Arc::clone(&armed_list),
Arc::clone(&armed_list_sequence),
Arc::clone(&armed_describe),
Arc::clone(&armed_reply_then_event),
Arc::clone(&armed_shutdown_then_unlink),
Arc::clone(&armed_shutdown_never_unlink),
Arc::clone(&list_flock_count),
));
FakeDaemon {
script: script_tx,
armed_list,
armed_list_sequence,
armed_describe,
armed_reply_then_event,
armed_shutdown_then_unlink,
armed_shutdown_never_unlink,
list_flock_count,
task,
}
}
pub async fn fake_client_with_push(path: &Path) -> (Client, FakeDaemon) {
fake_client_on(path).await
}
pub async fn fake_daemon_answering_with_ack(
path: &Path,
ack: HelloAck,
answer: impl Fn(&Request) -> Response + Send + Sync + Clone + 'static,
) -> mpsc::UnboundedReceiver<Envelope> {
let mut listener = Listener::bind(path).unwrap();
let (tx, rx) = mpsc::unbounded_channel();
tokio::spawn(async move {
while let Ok(stream) = listener.accept().await {
let tx = tx.clone();
let ack = ack.clone();
let answer = answer.clone();
tokio::spawn(async move {
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, ack).await;
while let Some(Ok(frame)) = frames.next().await {
let Ok(envelope) = decode_frame::<Envelope>(&frame) else {
break;
};
let id = envelope.id;
let reply = answer(&envelope.body);
if tx.send(envelope).is_err() {
break;
}
write_reply(&mut frames, id, reply).await;
}
});
}
});
rx
}
pub async fn fake_client_answering(
path: &Path,
answer: impl Fn(&Request) -> Response + Send + 'static,
) -> (Client, mpsc::UnboundedReceiver<Envelope>) {
let mut listener = Listener::bind(path).unwrap();
let (tx, rx) = mpsc::unbounded_channel();
tokio::spawn(async move {
let stream = listener.accept().await.unwrap();
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, sample_ack()).await;
while let Some(Ok(frame)) = frames.next().await {
let Ok(envelope) = decode_frame::<Envelope>(&frame) else {
break;
};
let id = envelope.id;
let reply = answer(&envelope.body);
if tx.send(envelope).is_err() {
break;
}
write_reply(&mut frames, id, reply).await;
}
});
let client = Client::connect(path).await.unwrap();
(client, rx)
}
pub async fn fake_client_capturing_envelopes(path: &Path) -> (Client, mpsc::Receiver<Envelope>) {
let mut listener = Listener::bind(path).unwrap();
let (tx, rx) = mpsc::channel(SCRIPT_CHANNEL_CAPACITY);
tokio::spawn(async move {
let stream = listener.accept().await.unwrap();
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, sample_ack()).await;
loop {
let envelope = read_envelope(&mut frames).await;
let id = envelope.id;
if tx.send(envelope).await.is_err() {
break;
}
write_reply(&mut frames, id, Response::Pong).await;
}
});
let client = Client::connect(path).await.unwrap();
(client, rx)
}
pub async fn fake_client_replying_err(
path: &Path,
code: RpcErrorCode,
message: &str,
) -> (Client, FakeDaemon) {
let (client, daemon) = fake_client_on(path).await;
daemon
.script
.send(ScriptCommand::ReplyErr(code, message.to_string()))
.await
.unwrap();
(client, daemon)
}
pub async fn fake_client_out_of_order(path: &Path) -> (Client, FakeDaemon) {
let (client, daemon) = fake_client_on(path).await;
daemon
.script
.send(ScriptCommand::ArmOutOfOrder)
.await
.unwrap();
(client, daemon)
}
pub async fn fake_client_event_then_reply(path: &Path) -> (Client, FakeDaemon) {
let (client, daemon) = fake_client_on(path).await;
daemon
.script
.send(ScriptCommand::EventThenReply)
.await
.unwrap();
(client, daemon)
}
pub async fn fake_client_that_closes_after_handshake(path: &Path) -> (Client, JoinHandle<()>) {
let mut listener = Listener::bind(path).unwrap();
let task = tokio::spawn(async move {
let stream = listener.accept().await.unwrap();
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, sample_ack()).await;
});
let client = Client::connect(path).await.unwrap();
(client, task)
}
pub async fn fake_client_that_dies_mid_request(path: &Path) -> (Client, JoinHandle<()>) {
let mut listener = Listener::bind(path).unwrap();
let task = tokio::spawn(async move {
let stream = listener.accept().await.unwrap();
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, sample_ack()).await;
let _envelope = read_envelope(&mut frames).await;
});
let client = Client::connect(path).await.unwrap();
(client, task)
}
pub async fn fake_client_that_never_replies(path: &Path) -> (Client, JoinHandle<()>) {
let mut listener = Listener::bind(path).unwrap();
let task = tokio::spawn(async move {
let stream = listener.accept().await.unwrap();
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, sample_ack()).await;
core::future::pending::<()>().await;
});
let client = Client::connect(path).await.unwrap();
(client, task)
}
#[must_use]
pub fn fast_opts() -> SpawnOptions {
SpawnOptions {
deadline: Duration::from_millis(600),
backoff_start: Duration::from_millis(10),
backoff_cap: Duration::from_millis(50),
handshake_timeout: Duration::from_millis(100),
}
}
pub fn start_fake_daemon_answering_on(path: &Path) {
let mut listener = Listener::bind(path).unwrap();
tokio::spawn(async move {
let stream = listener.accept().await.unwrap();
let mut frames = Framed::new(stream, codec());
let _hello = handshake(&mut frames, sample_ack()).await;
core::future::pending::<()>().await;
});
}
pub fn child_exiting_with(code: i32) -> std::io::Result<std::process::Child> {
std::process::Command::new("sh")
.args(["-c", &format!("exit {code}")])
.spawn()
}