use std::{path::PathBuf, time::Duration};
use futures::future::join_all;
use indicatif::ProgressBar;
use serde::Deserialize;
use crate::{
error::{Error, PathedError},
inventory::{Host, Inventory},
process::{Invocation, ProcessContext},
status::{self, DeploymentPhase, ProgressDisplay},
store_path::StorePath,
};
const TIMEOUT: Duration = Duration::from_mins(1);
const EXPRESSION: &str = r#"
let
flake = builtins.getFlake flakeReference;
localSystem = builtins.currentSystem;
verifiers =
if flake ? danceVerifiers && builtins.hasAttr localSystem flake.danceVerifiers
then builtins.getAttr localSystem flake.danceVerifiers
else {};
verifier =
if builtins.hasAttr flakeName verifiers
then builtins.getAttr flakeName verifiers
else null;
in
if verifier == null
then null
else {
output = verifier.outPath;
mainProgram =
if verifier ? meta && verifier.meta ? mainProgram
then verifier.meta.mainProgram
else throw "Dance verifier must define meta.mainProgram";
system = localSystem;
}
"#;
struct Verifier {
output: StorePath,
main_program: String,
system: String,
}
impl Verifier {
async fn discover(
host: &Host,
processes: &ProcessContext<'_>,
progress: &ProgressBar,
) -> Result<Option<Self>, Error> {
let metadata = Invocation::new(
processes,
format!("verify-{}-flake-metadata", host.id()),
"nix",
progress,
)
.arguments(["flake", "metadata", "--json", "--no-write-lock-file"])
.argument(host.flake_path())
.output()
.await?;
let metadata: FlakeMetadata = serde_json::from_str(&metadata).map_err(|source| {
Error::ParseFlakeMetadata(PathedError::new(host.flake_path().to_path_buf(), source))
})?;
let flake_reference = serde_json::to_string(&metadata.resolved_url)
.expect("flake reference should serialize as a Nix string");
let flake_name = serde_json::to_string(host.flake_name())
.expect("flake name should serialize as a Nix string");
let expression = format!(
"let flakeReference = {flake_reference}; flakeName = {flake_name}; in ({EXPRESSION})"
);
let output = Invocation::new(
processes,
format!("verify-{}-evaluate", host.id()),
"nix",
progress,
)
.arguments(["eval", "--json", "--impure", "--expr"])
.argument(expression)
.output()
.await?;
parse(host.id(), &output)
}
async fn build(
&self,
host: &Host,
processes: &ProcessContext<'_>,
progress: &ProgressBar,
) -> Result<(), Error> {
Invocation::new(
processes,
format!("verify-{}-build", host.id()),
"nix",
progress,
)
.arguments(["build", "--no-link"])
.argument(host.verifier_output(&self.system))
.status()
.await
}
fn executable(&self) -> PathBuf {
self.output.as_ref().join("bin").join(&self.main_program)
}
}
pub(crate) struct PreparedVerifier(Verifier);
impl PreparedVerifier {
pub(crate) async fn prepare(
host: &Host,
processes: &ProcessContext<'_>,
progress: &ProgressBar,
) -> Result<Option<Self>, Error> {
let Some(verifier) = Verifier::discover(host, processes, progress).await? else {
return Ok(None);
};
verifier.build(host, processes, progress).await?;
Ok(Some(Self(verifier)))
}
pub(crate) async fn run(
&self,
host: &Host,
processes: &ProcessContext<'_>,
progress: &ProgressBar,
) -> Result<(), Error> {
Invocation::new(
processes,
format!("verify-{}-run", host.id()),
self.0.executable(),
progress,
)
.environment("DANCE_HOST_ID", host.id())
.environment("DANCE_SSH_TARGET", host.ssh_url())
.timeout(TIMEOUT)
.status()
.await
}
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct FlakeMetadata {
resolved_url: String,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct VerifierRecord {
output: String,
main_program: String,
system: String,
}
pub(crate) enum ConfiguredOutcome {
Verified,
Missing,
}
pub(crate) async fn run_configured(
host: &Host,
processes: &ProcessContext<'_>,
progress: &ProgressBar,
) -> Result<ConfiguredOutcome, Error> {
status::set_phase(progress, host.id(), DeploymentPhase::BuildingVerifier);
let Some(verifier) = PreparedVerifier::prepare(host, processes, progress).await? else {
return Ok(ConfiguredOutcome::Missing);
};
status::set_phase(progress, host.id(), DeploymentPhase::RunningVerifier);
verifier.run(host, processes, progress).await?;
Ok(ConfiguredOutcome::Verified)
}
enum Outcome {
Verified,
Skipped,
Failed(Error),
}
async fn verify_host(
host: &Host,
processes: &ProcessContext<'_>,
progress: &ProgressBar,
) -> Outcome {
match run_configured(host, processes, progress).await {
Ok(ConfiguredOutcome::Verified) => {
status::verified(progress, host.id());
Outcome::Verified
}
Ok(ConfiguredOutcome::Missing) => {
status::verifier_missing(progress, host.id());
Outcome::Skipped
}
Err(error) => Outcome::Failed(error),
}
}
pub(crate) async fn verify(
inventory: Inventory,
processes: &ProcessContext<'_>,
) -> Result<(), Error> {
let hosts = inventory.into_iter().collect::<Vec<_>>();
let display = ProgressDisplay::new()?;
let progresses = display.hosts(hosts.iter().map(Host::id));
let outcomes = join_all(hosts.into_iter().zip(progresses.iter()).map(
|(host, progress)| async move {
let outcome = verify_host(&host, processes, progress).await;
if matches!(&outcome, Outcome::Failed(_)) {
status::fail(progress);
}
outcome
},
))
.await;
let mut verified = 0;
let mut skipped = 0;
let mut failed = 0;
let mut first_error = None;
for outcome in outcomes {
match outcome {
Outcome::Verified => verified += 1,
Outcome::Skipped => skipped += 1,
Outcome::Failed(error) => {
failed += 1;
first_error.get_or_insert(error);
}
}
}
println!("verification: {verified} passed, {skipped} skipped, {failed} failed");
first_error.map_or(Ok(()), Err)
}
fn parse(host: &str, output: &str) -> Result<Option<Verifier>, Error> {
let record: Option<VerifierRecord> =
serde_json::from_str(output).map_err(|source| Error::ParseVerifier {
host: host.to_owned(),
source,
})?;
record
.map(|verifier| {
let output = verifier.output.parse().map_err(Error::StorePath)?;
Ok(Verifier {
output,
main_program: verifier.main_program,
system: verifier.system,
})
})
.transpose()
}
#[cfg(test)]
mod tests {
use std::path::PathBuf;
use super::parse;
#[test]
fn parses_verifier_metadata() {
let verifier = parse(
"www",
r#"{
"output": "/nix/store/11111111111111111111111111111111-verifier",
"mainProgram": "verify-www",
"system": "x86_64-linux"
}"#,
)
.expect("valid verifier metadata should parse")
.expect("verifier should be present");
assert_eq!(
verifier.executable(),
PathBuf::from("/nix/store/11111111111111111111111111111111-verifier/bin/verify-www")
);
assert!(
parse("www", "null")
.expect("missing verifier should parse")
.is_none()
);
}
}