cargo.build, the WASI test runner, the console, and core.notify ordering
- cargo.build (native): one source copy, tests under WASI, release build to /state/cargo/builds/<n>/, process groups killed on cancel. The host writes the SDK copy to /plugins/cargo/sdk/ at start. - sausage test-runner: one instance per test, in parallel, with its own mount table (empty world, package folder at its path); answers core.lock, core.unlock, core.notify, core.log. - The console: rustyline, notifications while typing, ls/cat through the process view, methods, ps, log, activate, revert, stop, kill. - core.notify on stdout is handled in order, before the response.
This commit is contained in:
+274
-250
@@ -1,69 +1,48 @@
|
||||
//! Rust build helpers for the native cargo plugin.
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::time::Instant;
|
||||
|
||||
use anyhow::{Context, Result, anyhow, bail};
|
||||
use serde_json::Value;
|
||||
//! Native cargo builds, one immutable source copy, SDK installation, and process-group cancellation.
|
||||
use crate::{Host, world::World};
|
||||
use anyhow::{Context, Result, bail};
|
||||
use include_dir::{Dir, include_dir};
|
||||
use serde_json::{Value, json};
|
||||
use std::{
|
||||
path::{Path, PathBuf},
|
||||
sync::Arc,
|
||||
};
|
||||
use tokio::process::Command;
|
||||
|
||||
use include_dir::{Dir, include_dir};
|
||||
|
||||
use crate::world::{self, World};
|
||||
|
||||
/// The name reserved for the native Rust build plugin.
|
||||
/// The native build plugin.
|
||||
pub const ID: &str = "cargo";
|
||||
/// The WASI component target used for Rust plugin builds.
|
||||
/// The target used for builds and tests.
|
||||
pub const TARGET: &str = "wasm32-wasip2";
|
||||
static SDK: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/../sdk/src");
|
||||
static MACROS: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/../sdk/macros/src");
|
||||
static INTERFACE: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/../interface/src");
|
||||
|
||||
/// The source of the `sausage-actor` SDK.
|
||||
static SDK_SRC: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/../sdk/src");
|
||||
static SDK_MACROS: Dir<'_> = include_dir!("$CARGO_MANIFEST_DIR/../sdk/macros/src");
|
||||
|
||||
#[derive(Clone, Default, Debug)]
|
||||
/// The totals and output from a source tree's test run.
|
||||
#[derive(Clone, Default, Debug, serde::Serialize)]
|
||||
/// Test totals and captured output.
|
||||
pub struct TestResults {
|
||||
/// The number of tests that passed.
|
||||
pub passed: u64,
|
||||
/// The number of tests that failed.
|
||||
pub failed: u64,
|
||||
/// The test output retained for the caller.
|
||||
pub output: String,
|
||||
}
|
||||
|
||||
/// The component artifact and diagnostics from a successful build.
|
||||
pub struct BuildOutput {
|
||||
/// Host path of the published `.wasm` file.
|
||||
pub wasm: PathBuf,
|
||||
/// The elapsed build time in seconds.
|
||||
pub seconds: f64,
|
||||
/// The compiler diagnostics without progress lines.
|
||||
pub warnings: String,
|
||||
/// The totals and output of the test phase.
|
||||
pub tests: TestResults,
|
||||
}
|
||||
|
||||
/// A successful build, usable without a running host.
|
||||
#[derive(Debug)]
|
||||
/// The failed build or test phase and its diagnostics.
|
||||
pub struct BuildOutput {
|
||||
pub wasm: PathBuf,
|
||||
pub warnings: String,
|
||||
pub tests: TestResults,
|
||||
}
|
||||
/// A failed compiler or test phase, with its complete diagnostics.
|
||||
#[derive(Debug)]
|
||||
pub struct BuildFailure {
|
||||
/// The reason that the build could not complete.
|
||||
pub reason: String,
|
||||
/// The totals and output of the test phase.
|
||||
pub tests: TestResults,
|
||||
}
|
||||
|
||||
impl std::fmt::Display for BuildFailure {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
if self.tests.failed > 0 && !self.tests.output.is_empty() {
|
||||
write!(f, "{}:\n{}", self.reason, self.tests.output)
|
||||
} else {
|
||||
f.write_str(&self.reason)
|
||||
}
|
||||
fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
||||
write!(formatter, "{}\n{}", self.reason, self.tests.output)
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for BuildFailure {}
|
||||
|
||||
impl From<anyhow::Error> for BuildFailure {
|
||||
fn from(error: anyhow::Error) -> Self {
|
||||
Self {
|
||||
@@ -72,170 +51,271 @@ impl From<anyhow::Error> for BuildFailure {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// All builds share one target folder, so they run one at a time.
|
||||
/// A host-independent builder. Each builder serializes access to its work and target folders.
|
||||
pub struct Cargo {
|
||||
world: World,
|
||||
builds: tokio::sync::Mutex<()>,
|
||||
runner: PathBuf,
|
||||
}
|
||||
|
||||
impl Cargo {
|
||||
/// Create the plugin and install the SDK of this host into `public/sdk/`.
|
||||
/// Installs changed SDK files and selects the current sausage executable as runner.
|
||||
pub fn new(world: World) -> Result<Self> {
|
||||
let sdk = world.plugin_dir(ID).join("sdk");
|
||||
write_dir(&SDK_SRC, &sdk.join("src"))?;
|
||||
write_dir(&SDK_MACROS, &sdk.join("macros/src"))?;
|
||||
world::write_atomic(
|
||||
&sdk.join("Cargo.toml"),
|
||||
include_bytes!("../../sdk/Cargo.toml"),
|
||||
)?;
|
||||
world::write_atomic(
|
||||
&sdk.join("macros/Cargo.toml"),
|
||||
include_bytes!("../../sdk/macros/Cargo.toml"),
|
||||
)?;
|
||||
Ok(Self { world })
|
||||
}
|
||||
|
||||
/// Run native `cargo test` unless opted out, then build and publish the
|
||||
/// crate's `wasm32-wasip2` binary under `/plugin/cargo/public/builds/<n>/`.
|
||||
pub async fn build(
|
||||
&self,
|
||||
source: &Path,
|
||||
skip_tests: bool,
|
||||
) -> std::result::Result<BuildOutput, BuildFailure> {
|
||||
if !source.join("Cargo.toml").is_file() {
|
||||
return Err(BuildFailure {
|
||||
reason: format!("{} has no Cargo.toml", source.display()),
|
||||
tests: TestResults::default(),
|
||||
});
|
||||
let mut runner = std::env::current_exe()?;
|
||||
if runner
|
||||
.parent()
|
||||
.is_some_and(|parent| parent.file_name().is_some_and(|name| name == "deps"))
|
||||
{
|
||||
runner = runner.parent().unwrap().parent().unwrap().join("sausage");
|
||||
}
|
||||
let started = Instant::now();
|
||||
let data = self.world.state_dir(ID);
|
||||
let build_dir = data.join("work");
|
||||
world::replace_source(source, &build_dir)?;
|
||||
let manifest = build_dir.join("Cargo.toml");
|
||||
let original = std::fs::read_to_string(&manifest).context("read build manifest")?;
|
||||
let prepared = prepare_manifest(&original, Some(&self.world.plugin_dir(ID).join("sdk")))?;
|
||||
std::fs::write(&manifest, prepared).context("write prepared manifest")?;
|
||||
|
||||
let target_dir = data.join("target");
|
||||
let tests = if skip_tests {
|
||||
TestResults {
|
||||
output: "skipped (skip_tests=true)".into(),
|
||||
..TestResults::default()
|
||||
}
|
||||
} else {
|
||||
match run_tests(&build_dir, &target_dir).await {
|
||||
Ok(tests) => tests,
|
||||
Err(error) => {
|
||||
let output = format!("cannot run cargo tests: {error:#}");
|
||||
return Err(BuildFailure {
|
||||
reason: output.clone(),
|
||||
tests: TestResults {
|
||||
failed: 1,
|
||||
output,
|
||||
..TestResults::default()
|
||||
},
|
||||
});
|
||||
Self::with_runner(world, runner)
|
||||
}
|
||||
/// Installs the SDK and accepts an explicit sausage binary, including for init integrations.
|
||||
pub fn with_runner(world: World, runner: PathBuf) -> Result<Self> {
|
||||
let sdk = world.plugin_dir(ID).join("sdk");
|
||||
write_dir(&SDK, &sdk.join("src"))?;
|
||||
write_dir(&MACROS, &sdk.join("macros/src"))?;
|
||||
write_dir(&INTERFACE, &sdk.join("interface/src"))?;
|
||||
for (manifest, destination, interface_path) in [
|
||||
(
|
||||
include_str!("../../sdk/Cargo.toml"),
|
||||
sdk.join("Cargo.toml"),
|
||||
Some("interface"),
|
||||
),
|
||||
(
|
||||
include_str!("../../sdk/macros/Cargo.toml"),
|
||||
sdk.join("macros/Cargo.toml"),
|
||||
Some("../interface"),
|
||||
),
|
||||
(
|
||||
include_str!("../../interface/Cargo.toml"),
|
||||
sdk.join("interface/Cargo.toml"),
|
||||
None,
|
||||
),
|
||||
] {
|
||||
let mut document: toml_edit::DocumentMut = manifest.parse()?;
|
||||
document["workspace"] = toml_edit::table();
|
||||
if let Some(path) = interface_path {
|
||||
for section in ["dependencies", "dev-dependencies"] {
|
||||
if let Some(dependency) = document
|
||||
.get_mut(section)
|
||||
.and_then(|table| table.get_mut("sausage-interface"))
|
||||
{
|
||||
dependency["path"] = toml_edit::value(path);
|
||||
}
|
||||
}
|
||||
}
|
||||
write_changed(&destination, document.to_string().as_bytes())?;
|
||||
}
|
||||
Ok(Self {
|
||||
world,
|
||||
runner,
|
||||
builds: tokio::sync::Mutex::new(()),
|
||||
})
|
||||
}
|
||||
/// Registers cargo.build as a cancellable native process.
|
||||
pub fn register(self, host: &Host) {
|
||||
let builder = Arc::new(self);
|
||||
host.register_native(ID,Arc::new(move |_context,method,params| {
|
||||
let builder=builder.clone();
|
||||
Box::pin(async move {
|
||||
if method!="build" { return Err(crate::error(-32601,"cargo method not found")); }
|
||||
let plugin=params["plugin"].as_str().ok_or_else(||crate::error(-32602,"plugin must be a string"))?;
|
||||
match builder.build(&builder.world.plugin_dir(plugin).join("source")).await {
|
||||
Ok(output)=>Ok(json!({"wasm":format!("/{}",output.wasm.strip_prefix(&builder.world.root).unwrap().display()),"tests":output.tests,"warnings":output.warnings})),
|
||||
Err(failure)=>Err(json!({"code":-32004,"message":failure.reason,"data":{"tests":failure.tests}})),
|
||||
}
|
||||
})
|
||||
}));
|
||||
}
|
||||
/// Copies source once, runs WASI tests, then publishes a release component under state/cargo/builds.
|
||||
pub async fn build(&self, source: &Path) -> std::result::Result<BuildOutput, BuildFailure> {
|
||||
let _build = self.builds.lock().await;
|
||||
let work = self.world.state_dir(ID).join("work");
|
||||
let target = self.world.state_dir(ID).join("target");
|
||||
let source = source.to_path_buf();
|
||||
let copy = work.clone();
|
||||
let sdk = self.world.plugin_dir(ID).join("sdk");
|
||||
tokio::task::spawn_blocking(move || -> Result<()> {
|
||||
if copy.exists() {
|
||||
std::fs::remove_dir_all(©)?;
|
||||
}
|
||||
copy_source(&source, ©)?;
|
||||
let manifest = copy.join("Cargo.toml");
|
||||
let text = std::fs::read_to_string(&manifest)?;
|
||||
std::fs::write(manifest, prepare_manifest(&text, &sdk)?)?;
|
||||
Ok(())
|
||||
})
|
||||
.await
|
||||
.map_err(anyhow::Error::from)??;
|
||||
let mut test = Command::new("cargo");
|
||||
test.args(["test", "--offline", "--target", TARGET, "--target-dir"])
|
||||
.arg(&target)
|
||||
.current_dir(&work)
|
||||
.env(
|
||||
"CARGO_TARGET_WASM32_WASIP2_RUNNER",
|
||||
format!("{} test-runner", self.runner.display()),
|
||||
);
|
||||
let output = run_command(test).await?;
|
||||
let stdout = String::from_utf8_lossy(&output.stdout);
|
||||
let stderr = String::from_utf8_lossy(&output.stderr);
|
||||
let tests = TestResults {
|
||||
passed: test_count(&stdout, "passed"),
|
||||
failed: if output.status.success() {
|
||||
0
|
||||
} else {
|
||||
test_count(&stdout, "failed").max(1)
|
||||
},
|
||||
output: format!("{stdout}\n{stderr}"),
|
||||
};
|
||||
if tests.failed > 0 {
|
||||
if !output.status.success() {
|
||||
return Err(BuildFailure {
|
||||
reason: "unit tests failed".into(),
|
||||
reason: "WASI tests failed".into(),
|
||||
tests,
|
||||
});
|
||||
}
|
||||
|
||||
let build_result: Result<BuildOutput> = async {
|
||||
let mut cmd = Command::new("cargo");
|
||||
cmd.arg("build")
|
||||
.arg("--release")
|
||||
.arg("--target")
|
||||
.arg(TARGET)
|
||||
.arg("--message-format=json-render-diagnostics")
|
||||
.arg("--target-dir")
|
||||
.arg(&target_dir)
|
||||
.current_dir(&build_dir)
|
||||
.kill_on_drop(true);
|
||||
let out = cmd
|
||||
.output()
|
||||
.await
|
||||
.context("cannot run cargo (is it on PATH, with the wasm32-wasip2 target?)")?;
|
||||
let stderr = String::from_utf8_lossy(&out.stderr).to_string();
|
||||
if !out.status.success() {
|
||||
bail!("{}", strip_progress(&stderr));
|
||||
}
|
||||
let result = async {
|
||||
let mut build = Command::new("cargo");
|
||||
build
|
||||
.args([
|
||||
"build",
|
||||
"--offline",
|
||||
"--release",
|
||||
"--target",
|
||||
TARGET,
|
||||
"--message-format=json-render-diagnostics",
|
||||
"--target-dir",
|
||||
])
|
||||
.arg(&target)
|
||||
.current_dir(&work);
|
||||
let output = run_command(build).await?;
|
||||
let stdout = String::from_utf8_lossy(&output.stdout);
|
||||
let stderr = String::from_utf8_lossy(&output.stderr);
|
||||
let mut diagnostics = stderr.to_string();
|
||||
let mut artifact = None;
|
||||
for line in String::from_utf8_lossy(&out.stdout).lines() {
|
||||
if let Ok(v) = serde_json::from_str::<Value>(line)
|
||||
&& v["reason"] == "compiler-artifact"
|
||||
&& let Some(exe) = v["executable"].as_str()
|
||||
{
|
||||
artifact = Some(PathBuf::from(exe));
|
||||
for line in stdout.lines() {
|
||||
if let Ok(message) = serde_json::from_str::<Value>(line) {
|
||||
if message["reason"] == "compiler-artifact"
|
||||
&& let Some(executable) = message["executable"].as_str()
|
||||
{
|
||||
artifact = Some(PathBuf::from(executable));
|
||||
}
|
||||
if let Some(rendered) = message["message"]["rendered"].as_str() {
|
||||
diagnostics.push_str(rendered);
|
||||
}
|
||||
}
|
||||
}
|
||||
let artifact = artifact.ok_or_else(|| {
|
||||
anyhow!("cargo built no binary. Does the crate have a src/main.rs?")
|
||||
})?;
|
||||
|
||||
let n = next_build_number(&self.world.plugin_dir(ID).join("builds"))?;
|
||||
let dest_dir = self.world.plugin_dir(ID).join("builds").join(n.to_string());
|
||||
let name = artifact.file_name().context("artifact has no file name")?;
|
||||
let dest = dest_dir.join(name);
|
||||
world::write_atomic(&dest, &std::fs::read(&artifact)?)?;
|
||||
if !output.status.success() {
|
||||
bail!("{diagnostics}");
|
||||
}
|
||||
let artifact = artifact.context("cargo built no binary")?;
|
||||
let builds = self.world.state_dir(ID).join("builds");
|
||||
std::fs::create_dir_all(&builds)?;
|
||||
let number = std::fs::read_dir(&builds)?
|
||||
.filter_map(|entry| entry.ok()?.file_name().to_str()?.parse::<u64>().ok())
|
||||
.max()
|
||||
.unwrap_or(0)
|
||||
+ 1;
|
||||
let destination = builds
|
||||
.join(number.to_string())
|
||||
.join(artifact.file_name().unwrap());
|
||||
crate::world::write_atomic(&destination, &tokio::fs::read(artifact).await?)?;
|
||||
Ok(BuildOutput {
|
||||
wasm: dest,
|
||||
seconds: started.elapsed().as_secs_f64(),
|
||||
warnings: strip_progress(&stderr),
|
||||
wasm: destination,
|
||||
warnings: strip_progress(&diagnostics),
|
||||
tests: tests.clone(),
|
||||
})
|
||||
}
|
||||
.await;
|
||||
build_result.map_err(|error| BuildFailure {
|
||||
result.map_err(|error: anyhow::Error| BuildFailure {
|
||||
reason: format!("{error:#}"),
|
||||
tests,
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
/// Run tests for the host triple: WASI crates' pure-logic tests can use the
|
||||
/// normal Rust test harness without needing a WASI test runner.
|
||||
async fn run_tests(build_dir: &Path, target_dir: &Path) -> Result<TestResults> {
|
||||
let mut cmd = Command::new("cargo");
|
||||
cmd.arg("test")
|
||||
.arg("--target-dir")
|
||||
.arg(target_dir)
|
||||
.current_dir(build_dir)
|
||||
.kill_on_drop(true);
|
||||
let out = cmd.output().await.context("cannot run cargo test")?;
|
||||
let stdout = String::from_utf8_lossy(&out.stdout).to_string();
|
||||
let stderr = String::from_utf8_lossy(&out.stderr).to_string();
|
||||
let combined = match (stdout.is_empty(), stderr.is_empty()) {
|
||||
(true, true) => String::new(),
|
||||
(false, true) => stdout,
|
||||
(true, false) => stderr,
|
||||
(false, false) => format!("{stdout}\n{stderr}"),
|
||||
};
|
||||
let output = strip_progress(&combined);
|
||||
let passed = test_count(&output, "passed");
|
||||
let mut failed = test_count(&output, "failed");
|
||||
// Compilation failures and runner errors have no `test result` summary,
|
||||
// but still make the default test phase fail.
|
||||
if !out.status.success() && failed == 0 {
|
||||
failed = 1;
|
||||
/// Kills cargo and every descendant, including tests and build scripts, on cancellation.
|
||||
struct ProcessGroup(u32);
|
||||
impl Drop for ProcessGroup {
|
||||
fn drop(&mut self) {
|
||||
let _ = nix::sys::signal::killpg(
|
||||
nix::unistd::Pid::from_raw(self.0 as i32),
|
||||
nix::sys::signal::Signal::SIGKILL,
|
||||
);
|
||||
}
|
||||
Ok(TestResults {
|
||||
passed,
|
||||
failed,
|
||||
output,
|
||||
})
|
||||
}
|
||||
|
||||
/// Count the `passed` or `failed` totals in cargo's per-target test summaries.
|
||||
/// Starts one process group and retains its guard across all output collection.
|
||||
async fn run_command(mut command: Command) -> Result<std::process::Output> {
|
||||
command
|
||||
.process_group(0)
|
||||
.kill_on_drop(true)
|
||||
.stdout(std::process::Stdio::piped())
|
||||
.stderr(std::process::Stdio::piped());
|
||||
let child = command.spawn().context("start cargo")?;
|
||||
let _group = ProcessGroup(child.id().unwrap());
|
||||
Ok(child.wait_with_output().await?)
|
||||
}
|
||||
/// Copies only source, excluding build outputs and git internals at every level.
|
||||
fn copy_source(source: &Path, destination: &Path) -> Result<()> {
|
||||
std::fs::create_dir_all(destination)?;
|
||||
for entry in std::fs::read_dir(source)? {
|
||||
let entry = entry?;
|
||||
if matches!(entry.file_name().to_str(), Some("target" | ".git")) {
|
||||
continue;
|
||||
}
|
||||
if entry.file_type()?.is_dir() {
|
||||
copy_source(&entry.path(), &destination.join(entry.file_name()))?;
|
||||
} else {
|
||||
std::fs::copy(entry.path(), destination.join(entry.file_name()))?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
/// Repoints SDK dependencies without discarding feature flags and detaches the copied crate's workspace.
|
||||
fn prepare_manifest(text: &str, sdk: &Path) -> Result<String> {
|
||||
let mut document: toml_edit::DocumentMut = text.parse()?;
|
||||
for section in ["dependencies", "dev-dependencies", "build-dependencies"] {
|
||||
if let Some(dependency) = document
|
||||
.get_mut(section)
|
||||
.and_then(|table| table.get_mut("sausage-plugin"))
|
||||
{
|
||||
let features = dependency.get("features").cloned();
|
||||
let defaults = dependency.get("default-features").cloned();
|
||||
let mut replacement = toml_edit::InlineTable::new();
|
||||
replacement.insert("path", sdk.display().to_string().into());
|
||||
if let Some(features) = features.and_then(|value| value.as_value().cloned()) {
|
||||
replacement.insert("features", features);
|
||||
}
|
||||
if let Some(defaults) = defaults.and_then(|value| value.as_value().cloned()) {
|
||||
replacement.insert("default-features", defaults);
|
||||
}
|
||||
*dependency = toml_edit::value(replacement);
|
||||
}
|
||||
}
|
||||
document["workspace"] = toml_edit::table();
|
||||
Ok(document.to_string())
|
||||
}
|
||||
/// Writes embedded sources only when their bytes changed.
|
||||
fn write_changed(path: &Path, bytes: &[u8]) -> Result<()> {
|
||||
if std::fs::read(path).ok().as_deref() != Some(bytes) {
|
||||
std::fs::create_dir_all(path.parent().unwrap())?;
|
||||
std::fs::write(path, bytes)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
/// Installs one embedded source tree without touching unchanged files.
|
||||
fn write_dir(directory: &Dir<'_>, destination: &Path) -> Result<()> {
|
||||
for file in directory.files() {
|
||||
write_changed(&destination.join(file.path()), file.contents())?;
|
||||
}
|
||||
for directory in directory.dirs() {
|
||||
write_dir(directory, destination)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
/// Counts only final libtest summaries, never individual status lines.
|
||||
fn test_count(output: &str, field: &str) -> u64 {
|
||||
output
|
||||
.lines()
|
||||
.filter_map(|line| line.split_once("test result:").map(|(_, rest)| rest))
|
||||
.filter_map(|line| line.strip_prefix("test result:"))
|
||||
.flat_map(|summary| summary.split(';'))
|
||||
.filter_map(|part| {
|
||||
let words: Vec<_> = part.split_whitespace().collect();
|
||||
@@ -244,77 +324,21 @@ fn test_count(output: &str, field: &str) -> u64 {
|
||||
})
|
||||
.sum()
|
||||
}
|
||||
|
||||
/// Point a `sausage-actor` dependency at `sdk` (keeping its features), and
|
||||
/// add an empty `[workspace]`, so the crate never joins a parent workspace.
|
||||
fn prepare_manifest(text: &str, sdk: Option<&Path>) -> Result<String> {
|
||||
let mut doc: toml_edit::DocumentMut = text.parse()?;
|
||||
if let Some(sdk) = sdk {
|
||||
for section in ["dependencies", "dev-dependencies", "build-dependencies"] {
|
||||
let Some(dep) = doc
|
||||
.get_mut(section)
|
||||
.and_then(|t| t.get_mut("sausage-actor"))
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
let mut table = dep.as_inline_table().cloned().unwrap_or_default();
|
||||
for key in ["version", "path", "git", "branch", "tag", "rev", "registry"] {
|
||||
table.remove(key);
|
||||
}
|
||||
table.insert("path", sdk.display().to_string().into());
|
||||
*dep = toml_edit::value(table);
|
||||
}
|
||||
}
|
||||
if doc.get("workspace").is_none() {
|
||||
doc["workspace"] = toml_edit::table();
|
||||
}
|
||||
Ok(doc.to_string())
|
||||
}
|
||||
|
||||
/// Write the files of `dir` below `to`. Skip files that did not change, so
|
||||
/// that cargo does not rebuild the SDK at every start.
|
||||
fn write_dir(dir: &Dir<'_>, to: &Path) -> Result<()> {
|
||||
for file in dir.files() {
|
||||
let dest = to.join(file.path());
|
||||
let contents = match file.path().file_name() {
|
||||
Some(n) if n == "Cargo.toml" => {
|
||||
prepare_manifest(file.contents_utf8().context("Cargo.toml")?, None)?.into_bytes()
|
||||
}
|
||||
_ => file.contents().to_vec(),
|
||||
};
|
||||
if std::fs::read(&dest).ok() != Some(contents.clone()) {
|
||||
std::fs::create_dir_all(dest.parent().context("no parent")?)?;
|
||||
std::fs::write(&dest, contents)?;
|
||||
}
|
||||
}
|
||||
for sub in dir.dirs() {
|
||||
write_dir(sub, to)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn next_build_number(dir: &Path) -> Result<u64> {
|
||||
std::fs::create_dir_all(dir)?;
|
||||
let max = std::fs::read_dir(dir)?
|
||||
.filter_map(|e| e.ok()?.file_name().to_str()?.parse::<u64>().ok())
|
||||
.max()
|
||||
.unwrap_or(0);
|
||||
Ok(max + 1)
|
||||
}
|
||||
|
||||
/// Remove cargo's "Compiling ..." progress lines. Keep diagnostics.
|
||||
fn strip_progress(stderr: &str) -> String {
|
||||
stderr
|
||||
/// Removes progress lines while retaining compiler diagnostics.
|
||||
fn strip_progress(output: &str) -> String {
|
||||
output
|
||||
.lines()
|
||||
.filter(|l| {
|
||||
let t = l.trim_start();
|
||||
!(t.starts_with("Compiling ")
|
||||
|| t.starts_with("Downloaded ")
|
||||
|| t.starts_with("Downloading ")
|
||||
|| t.starts_with("Updating ")
|
||||
|| t.starts_with("Locking ")
|
||||
|| t.starts_with("Adding ")
|
||||
|| t.starts_with("Blocking "))
|
||||
.filter(|line| {
|
||||
![
|
||||
"Compiling ",
|
||||
"Finished ",
|
||||
"Blocking ",
|
||||
"Updating ",
|
||||
"Locking ",
|
||||
"Adding ",
|
||||
]
|
||||
.iter()
|
||||
.any(|prefix| line.trim_start().starts_with(prefix))
|
||||
})
|
||||
.collect::<Vec<_>>()
|
||||
.join("\n")
|
||||
|
||||
Reference in New Issue
Block a user