use std::{
io,
process::{ExitStatus, Stdio},
time::Duration,
};
use thiserror::Error;
use tokio::{
io::AsyncReadExt,
process::{Child, ChildStdin, Command},
task::JoinHandle,
};
use super::ARGUMENTS;
const ACQUIRED: &[u8] = b"dance-lock-acquired\n";
const ACQUISITION_TIMEOUT: Duration = Duration::from_mins(1);
const REMOTE_COMMAND: &str = concat!(
"exec /run/current-system/sw/bin/flock --exclusive --nonblock ",
"--conflict-exit-code 75 /run/lock/dance-deployment.lock ",
"/run/current-system/sw/bin/sh -c '",
"printf \"dance-lock-acquired\\n\"; ",
"exec /run/current-system/sw/bin/cat >/dev/null'",
);
#[derive(Debug, Error)]
pub(crate) enum LockError {
#[error("deployment lock on host `{host}` is already held")]
Unavailable {
host: String,
},
#[error("failed to start deployment lock on host `{host}`")]
Spawn {
host: String,
#[source]
source: io::Error,
},
#[error("timed out acquiring deployment lock on host `{host}`")]
AcquisitionTimedOut {
host: String,
},
#[error("failed to acquire deployment lock on host `{host}` ({status}): {stderr}")]
AcquisitionFailed {
host: String,
status: ExitStatus,
stderr: String,
},
#[error("deployment lock on host `{host}` returned an invalid acknowledgement")]
InvalidAcknowledgement {
host: String,
},
#[error("failed to read deployment lock process for host `{host}`")]
Output {
host: String,
#[source]
source: io::Error,
},
}
pub(crate) struct DeploymentLock {
_stdin: ChildStdin,
_child: Child,
_stderr: JoinHandle<Result<Vec<u8>, io::Error>>,
}
impl DeploymentLock {
pub(crate) async fn acquire(host: &str, ssh_target: &str) -> Result<Self, LockError> {
let mut command = Command::new("ssh");
command.args(ARGUMENTS).arg(ssh_target).arg(REMOTE_COMMAND);
Self::spawn(host, command).await
}
async fn spawn(host: &str, mut command: Command) -> Result<Self, LockError> {
command
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true);
let mut child = command.spawn().map_err(|source| LockError::Spawn {
host: host.to_owned(),
source,
})?;
let stdin = child
.stdin
.take()
.expect("lock command standard input should be piped");
let mut stdout = child
.stdout
.take()
.expect("lock command standard output should be piped");
let mut stderr = child
.stderr
.take()
.expect("lock command standard error should be piped");
let stderr = tokio::spawn(async move {
let mut output = Vec::new();
stderr.read_to_end(&mut output).await?;
Ok::<_, io::Error>(output)
});
let mut acknowledgement = vec![0; ACQUIRED.len()];
let acquisition =
tokio::time::timeout(ACQUISITION_TIMEOUT, stdout.read_exact(&mut acknowledgement))
.await;
match acquisition {
Ok(Ok(_)) if acknowledgement == ACQUIRED => Ok(Self {
_stdin: stdin,
_child: child,
_stderr: stderr,
}),
Ok(Ok(_)) => {
drop(stdin);
terminate(&mut child).await;
let _ = stderr.await;
Err(LockError::InvalidAcknowledgement {
host: host.to_owned(),
})
}
Ok(Err(source)) => {
drop(stdin);
let status = child
.wait()
.await
.map_err(|wait_source| LockError::Output {
host: host.to_owned(),
source: wait_source,
})?;
let stderr = stderr_text(stderr, host).await?;
if status.code() == Some(75) {
Err(LockError::Unavailable {
host: host.to_owned(),
})
} else if source.kind() == io::ErrorKind::UnexpectedEof {
Err(LockError::AcquisitionFailed {
host: host.to_owned(),
status,
stderr,
})
} else {
Err(LockError::Output {
host: host.to_owned(),
source,
})
}
}
Err(_) => {
drop(stdin);
terminate(&mut child).await;
let _ = stderr.await;
Err(LockError::AcquisitionTimedOut {
host: host.to_owned(),
})
}
}
}
}
async fn stderr_text(
stderr: JoinHandle<Result<Vec<u8>, io::Error>>,
host: &str,
) -> Result<String, LockError> {
let output = stderr.await.map_err(|source| LockError::Output {
host: host.to_owned(),
source: io::Error::other(source),
})?;
let output = output.map_err(|source| LockError::Output {
host: host.to_owned(),
source,
})?;
let output = String::from_utf8_lossy(&output).trim().to_owned();
Ok(if output.is_empty() {
"no standard error output".to_owned()
} else {
output
})
}
async fn terminate(child: &mut Child) {
let _ = child.kill().await;
}
#[cfg(all(test, target_os = "linux"))]
mod tests {
use std::time::Duration;
use tempfile::tempdir;
use tokio::process::Command;
use super::{ACQUIRED, DeploymentLock, LockError};
fn command(path: &std::path::Path) -> Command {
let mut command = Command::new("flock");
command
.args(["--exclusive", "--nonblock", "--conflict-exit-code", "75"])
.arg(path)
.arg("sh")
.arg("-c")
.arg(format!(
"printf '{}'; exec cat >/dev/null",
String::from_utf8_lossy(ACQUIRED)
));
command
}
#[tokio::test]
async fn locks_are_exclusive_and_release_on_drop() {
let directory = tempdir().expect("temporary directory should be created");
let path = directory.path().join("deployment.lock");
let first = DeploymentLock::spawn("test", command(&path))
.await
.expect("first lock should be acquired");
let conflict = DeploymentLock::spawn("test", command(&path)).await;
assert!(matches!(conflict, Err(LockError::Unavailable { .. })));
drop(first);
let second = tokio::time::timeout(Duration::from_secs(1), async {
loop {
match DeploymentLock::spawn("test", command(&path)).await {
Ok(lock) => break lock,
Err(LockError::Unavailable { .. }) => tokio::task::yield_now().await,
Err(error) => panic!("released lock should be acquirable: {error}"),
}
}
})
.await
.expect("dropped lock should be released promptly");
drop(second);
}
}