use super::Runner;
use super::generated::{general, line_in, program_name};
use crate::toolchain::cargo::Problem;
use crate::toolchain::{Command, Outcome, run};
use serde::Deserialize;
use serde_json::{Value, json};
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::time::Duration;
#[derive(Clone, Default)]
pub(super) struct Built {
pub(super) binary: Option<PathBuf>,
pub(super) dropped: HashMap<usize, String>,
pub(super) failure: Option<String>,
}
struct Building {
built: Built,
live: Vec<bool>,
}
impl Building {
fn settle(&mut self, name: &str, rendered: &Rendered, problems: &[Problem]) -> bool {
let before = self.built.dropped.len();
for problem in problems {
if let Some(piece) = line_in(problem, name).and_then(|line| rendered.lines.get(&line)) {
self.live[*piece] = false;
self.built.dropped.entry(*piece).or_insert_with(|| problem.message.clone());
}
}
if self.built.dropped.len() > before {
return !self.live.contains(&true);
}
let stops =
problems.iter().find(|problem| problem.target == name || !problem.target.starts_with("p_"));
self.built.failure = stops.map(general);
true
}
}
pub(super) struct Rendered {
pub(super) source: String,
pub(super) lines: HashMap<usize, usize>,
}
pub(super) type Render<'a> = &'a dyn Fn(&[bool]) -> Rendered;
#[derive(Clone, Debug, Default, Deserialize)]
#[serde(default)]
pub(super) struct Line {
pub(super) value: Value,
pub(super) panic: Option<String>,
pub(super) timeout: bool,
pub(super) failed: Option<String>,
pub(super) lost: Option<String>,
}
impl Runner {
pub(super) fn build_program(&self, pieces: usize, render: Render) -> Built {
self.build_programs(&[(pieces, render)]).remove(0)
}
pub(super) fn build_programs(&self, programs: &[(usize, Render)]) -> Vec<Built> {
let mut states: Vec<Building> = programs
.iter()
.map(|(pieces, _)| Building { built: Built::default(), live: vec![true; *pieces] })
.collect();
let mut open: Vec<usize> = (0..programs.len()).collect();
while !open.is_empty() {
let rendered: Vec<(usize, String, Rendered)> = open
.iter()
.map(|&k| {
let rendered = (programs[k].1)(&states[k].live);
(k, program_name("p", &rendered.source), rendered)
})
.collect();
let sources: Vec<(String, String)> =
rendered.iter().map(|(_, name, rendered)| (name.clone(), rendered.source.clone())).collect();
let problems = self.build(&sources);
open.clear();
for (k, name, source) in rendered {
if !states[k].settle(&name, &source, &problems) {
open.push(k);
} else if states[k].built.failure.is_none()
&& (states[k].live.is_empty() || states[k].live.contains(&true))
{
states[k].built.binary = Some(self.binary(&name));
}
}
}
states.into_iter().map(|state| state.built).collect()
}
pub(super) fn serve(
&self,
binary: &Path,
cases: Option<Value>,
count: usize,
) -> Result<Vec<Line>, String> {
let dir = self.scratch(&program_name(
"j",
&format!("{binary:?}{:?}{:?}", std::time::Instant::now(), std::thread::current().id()),
))?;
let snapshots = &self.snapshots;
let job = json!({ "timeoutMs": self.limits.timeout_ms, "snapshots": { "dir": snapshots.dir, "data": snapshots.data }, "manifests": self.manifests, "cases": cases });
let (job_file, results) = (dir.join("job.json"), dir.join("results"));
std::fs::write(&job_file, job.to_string())
.map_err(|err| format!("cannot write {}: {err}", job_file.display()))?;
let mut answers: Vec<Line> = Vec::new();
while answers.len() < count {
let args = [&job_file, &results]
.map(|path| path.to_string_lossy().into_owned())
.into_iter()
.chain([answers.len().to_string()]);
let backstop = self.timeout() * (count - answers.len()) as u32 + Duration::from_secs(10);
let command = Command {
program: binary.to_path_buf(),
args: args.collect(),
dir: self.analysis.root.clone(),
timeout: Some(backstop),
..Command::default()
};
let outcome = self.running(|| run(&command));
let before = answers.len();
answers = read_lines(&results)?;
if answers.len() < count && (answers.len() == before || !answers[answers.len() - 1].timeout) {
record_lost(&results, &outcome)?;
answers = read_lines(&results)?;
}
}
let _ = std::fs::remove_dir_all(&dir);
Ok(answers)
}
}
fn record_lost(results: &Path, outcome: &Outcome) -> Result<(), String> {
let written = json!({ "lost": lost(outcome) });
let cannot = |err: std::io::Error| format!("cannot write {}: {err}", results.display());
let mut file = std::fs::OpenOptions::new().create(true).append(true).open(results).map_err(cannot)?;
std::io::Write::write_all(&mut file, format!("{written}\n").as_bytes()).map_err(cannot)
}
fn lost(outcome: &Outcome) -> String {
match (outcome.code, outcome.stderr.lines().rev().find(|line| !line.trim().is_empty())) {
(None, _) => "the program did not answer and was stopped".to_string(),
(Some(code), Some(said)) => format!("exited with status {code}: {}", said.trim()),
(Some(code), None) => format!("exited with status {code}"),
}
}
fn read_lines(results: &Path) -> Result<Vec<Line>, String> {
let text = match std::fs::read_to_string(results) {
Ok(text) => text,
Err(err) if err.kind() == std::io::ErrorKind::NotFound => String::new(),
Err(err) => return Err(format!("cannot read {}: {err}", results.display())),
};
let lines: Vec<Line> = text.lines().filter_map(|line| serde_json::from_str(line).ok()).collect();
match lines.iter().find_map(|line| line.failed.clone()) {
Some(failed) => Err(failed),
None => Ok(lines),
}
}