use core::fmt;
use std::path::Path;
use std::process::ExitStatus;
use std::time::{Duration, Instant};
use crate::client::Client;
use crate::connection::ConnectError;
pub const SPAWN_DEADLINE: Duration = Duration::from_secs(30);
pub const BACKOFF_START: Duration = Duration::from_millis(100);
pub const BACKOFF_CAP: Duration = Duration::from_secs(5);
pub use crate::connection::HANDSHAKE_TIMEOUT;
pub const DAEMON_ALREADY_RUNNING: i32 = 10;
#[derive(Debug, Clone)]
pub struct SpawnOptions {
pub deadline: Duration,
pub backoff_start: Duration,
pub backoff_cap: Duration,
pub handshake_timeout: Duration,
}
impl Default for SpawnOptions {
fn default() -> Self {
Self {
deadline: SPAWN_DEADLINE,
backoff_start: BACKOFF_START,
backoff_cap: BACKOFF_CAP,
handshake_timeout: HANDSHAKE_TIMEOUT,
}
}
}
#[derive(Debug)]
pub enum SpawnOutcome {
Connected(Client),
Spawned(Client),
}
#[derive(Debug)]
#[non_exhaustive]
pub enum SpawnError {
Connect(ConnectError),
Launch(std::io::Error),
DaemonExited {
status: ExitStatus,
},
DeadlineExpired {
after: Duration,
last: Option<ConnectError>,
},
}
impl fmt::Display for SpawnError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Connect(err) => write!(f, "{err}"),
Self::Launch(err) => write!(f, "failed to launch the daemon: {err}"),
Self::DaemonExited { status } => {
write!(
f,
"the daemon process exited before it started answering: {status}"
)
}
Self::DeadlineExpired {
after,
last: Some(last),
} => write!(f, "no daemon answered within {after:?}: {last}"),
Self::DeadlineExpired { after, last: None } => {
write!(f, "no daemon answered within {after:?}")
}
}
}
}
impl core::error::Error for SpawnError {
fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
match self {
Self::Connect(err) => Some(err),
Self::Launch(err) => Some(err),
Self::DaemonExited { .. } => None,
Self::DeadlineExpired { last, .. } => last
.as_ref()
.map(|err| err as &(dyn core::error::Error + 'static)),
}
}
}
pub async fn connect_or_spawn<L>(socket: &Path, launch: L) -> Result<SpawnOutcome, SpawnError>
where
L: FnOnce() -> std::io::Result<std::process::Child> + Send + 'static,
{
connect_or_spawn_with(socket, launch, SpawnOptions::default()).await
}
pub async fn connect_or_spawn_with<L>(
socket: &Path,
launch: L,
opts: SpawnOptions,
) -> Result<SpawnOutcome, SpawnError>
where
L: FnOnce() -> std::io::Result<std::process::Child> + Send + 'static,
{
match Client::connect_with_timeout(socket, opts.handshake_timeout).await {
Ok(client) => return Ok(SpawnOutcome::Connected(client)),
Err(ConnectError::Connect { .. }) => {}
Err(err @ ConnectError::HandshakeTimeout { .. }) => {
return probe_until_ready(socket, None, opts, Some(err)).await;
}
Err(other) => return Err(SpawnError::Connect(other)),
}
let launched = tokio::task::spawn_blocking(launch).await;
let child = match launched {
Ok(result) => result.map_err(SpawnError::Launch)?,
Err(join) if join.is_panic() => std::panic::resume_unwind(join.into_panic()),
Err(join) => return Err(SpawnError::Launch(std::io::Error::other(join))),
};
probe_until_ready(socket, Some(child), opts, None).await
}
async fn probe_until_ready(
socket: &Path,
mut child: Option<std::process::Child>,
opts: SpawnOptions,
seed: Option<ConnectError>,
) -> Result<SpawnOutcome, SpawnError> {
let start = Instant::now();
let mut backoff = opts.backoff_start;
let mut last = seed;
let mut child_reaped = false;
loop {
if start.elapsed() >= opts.deadline {
return Err(SpawnError::DeadlineExpired {
after: opts.deadline,
last,
});
}
if !child_reaped
&& let Some(proc) = child.as_mut()
&& let Ok(Some(status)) = proc.try_wait()
{
child_reaped = true;
if status.code() != Some(DAEMON_ALREADY_RUNNING) {
return Err(SpawnError::DaemonExited { status });
}
}
tokio::time::sleep(backoff).await;
backoff = backoff.mul_f64(1.5).min(opts.backoff_cap);
match Client::connect_with_timeout(socket, opts.handshake_timeout).await {
Ok(client) => return Ok(SpawnOutcome::Spawned(client)),
Err(err @ ConnectError::ProtocolMismatch { .. }) => {
return Err(SpawnError::Connect(err));
}
Err(err) => last = Some(err),
}
}
}