Skip to content

Commit b2e4ff7

Browse files
borsbors
committed
Auto merge of #2134 - alexcrichton:build-script-input, r=brson
Currently Cargo is quite conservative in how it determines whether a build script should be run. The heuristic used is "did any file in the project directory change", but this is almost always guaranteed to be too coarse grained in situations like: * If the build script takes a long time to run it's advantageous to run it as few times as possible. Being able to inform Cargo about precisely when a build script should be run should provide more robust support here. * Build scripts may not always have all of their dependencies in-tree or in the crate root. Sometimes a dependency could be elsewhere in a repository and scripts need a method of informing Cargo about this (as currently these compiles don't happen then they should). This commit adds this support in build scripts via a new `rerun-if-changed` directive which can be printed to standard output (using the standard Cargo metadata format). The value for this key is a path relative to the crate root, and Cargo will only look at these paths when determining whether to rerun the build script. Any other file changes will not trigger the build script to be rerun. Currently the printed paths may either be a file or a directory, and a directory is deeply traversed. The heuristic for trigger a rerun is detecting whether any input file has been modified since the build script was last run (determined by looking at the modification time of the output file of the build script). This current implementation means that if you depend on a directory and then delete a file within it the build script won't be rerun, but this is already the case and can perhaps be patched up later. Future extensions could possibly include the usage of glob patterns in build script paths like the `include` and `exclude` features of `Cargo.toml`, but these should be backwards compatible to add in the future. Closes #1162
2 parents 1f4696e + 7c97c5b commit b2e4ff7

File tree

6 files changed

+171
-24
lines changed

6 files changed

+171
-24
lines changed

‎src/cargo/ops/cargo_compile.rs

+1
Original file line numberDiff line numberDiff line change
@@ -467,6 +467,7 @@ fn scrape_target_config(config: &Config, triple: &str)
467467
library_links: Vec::new(),
468468
cfgs: Vec::new(),
469469
metadata: Vec::new(),
470+
rerun_if_changed: Vec::new(),
470471
};
471472
let key = format!("{}.{}", key, lib_name);
472473
let table = try!(config.get_table(&key)).unwrap().0;

‎src/cargo/ops/cargo_rustc/context.rs

+2
Original file line numberDiff line numberDiff line change
@@ -31,6 +31,7 @@ pub struct Context<'a, 'cfg: 'a> {
3131
pub sources: &'a SourceMap<'cfg>,
3232
pub compilation: Compilation<'cfg>,
3333
pub build_state: Arc<BuildState>,
34+
pub build_explicit_deps: HashMap<Unit<'a>, (PathBuf, Vec<String>)>,
3435
pub exec_engine: Arc<Box<ExecEngine>>,
3536
pub fingerprints: HashMap<Unit<'a>, Arc<Fingerprint>>,
3637
pub compiled: HashSet<Unit<'a>>,
@@ -92,6 +93,7 @@ impl<'a, 'cfg> Context<'a, 'cfg> {
9293
profiles: profiles,
9394
compiled: HashSet::new(),
9495
build_scripts: HashMap::new(),
96+
build_explicit_deps: HashMap::new(),
9597
})
9698
}
9799

‎src/cargo/ops/cargo_rustc/custom_build.rs

+31-11
Original file line numberDiff line numberDiff line change
@@ -1,7 +1,7 @@
11
use std::collections::{HashMap, BTreeSet};
22
use std::fs;
33
use std::io::prelude::*;
4-
use std::path::PathBuf;
4+
use std::path::{PathBuf, Path};
55
use std::str;
66
use std::sync::{Mutex, Arc};
77

@@ -25,6 +25,8 @@ pub struct BuildOutput {
2525
pub cfgs: Vec<String>,
2626
/// Metadata to pass to the immediate dependencies
2727
pub metadata: Vec<(String, String)>,
28+
/// Glob paths to trigger a rerun of this build script.
29+
pub rerun_if_changed: Vec<String>,
2830
}
2931

3032
pub type BuildMap = HashMap<(PackageId, Kind), BuildOutput>;
@@ -45,8 +47,8 @@ pub struct BuildScripts {
4547
/// prepare work for. If the requirement is specified as both the target and the
4648
/// host platforms it is assumed that the two are equal and the build script is
4749
/// only run once (not twice).
48-
pub fn prepare(cx: &mut Context, unit: &Unit)
49-
-> CargoResult<(Work, Work, Freshness)> {
50+
pub fn prepare<'a, 'cfg>(cx: &mut Context<'a, 'cfg>, unit: &Unit<'a>)
51+
-> CargoResult<(Work, Work, Freshness)> {
5052
let _p = profile::start(format!("build script prepare: {}/{}",
5153
unit.pkg, unit.target.name()));
5254
let key = (unit.pkg.package_id().clone(), unit.kind);
@@ -65,7 +67,8 @@ pub fn prepare(cx: &mut Context, unit: &Unit)
6567
Ok((work_dirty.then(dirty), work_fresh.then(fresh), freshness))
6668
}
6769

68-
fn build_work(cx: &mut Context, unit: &Unit) -> CargoResult<(Work, Work)> {
70+
fn build_work<'a, 'cfg>(cx: &mut Context<'a, 'cfg>, unit: &Unit<'a>)
71+
-> CargoResult<(Work, Work)> {
6972
let (script_output, build_output) = {
7073
(cx.layout(unit.pkg, Kind::Host).build(unit.pkg),
7174
cx.layout(unit.pkg, unit.kind).build_out(unit.pkg))
@@ -119,11 +122,20 @@ fn build_work(cx: &mut Context, unit: &Unit) -> CargoResult<(Work, Work)> {
119122
let pkg_name = unit.pkg.to_string();
120123
let build_state = cx.build_state.clone();
121124
let id = unit.pkg.package_id().clone();
125+
let output_file = build_output.parent().unwrap().join("output");
122126
let all = (id.clone(), pkg_name.clone(), build_state.clone(),
123-
build_output.clone());
127+
output_file.clone());
124128
let build_scripts = super::load_build_deps(cx, unit);
125129
let kind = unit.kind;
126130

131+
// Check to see if the build script as already run, and if it has keep
132+
// track of whether it has told us about some explicit dependencies
133+
let prev_output = BuildOutput::parse_file(&output_file, &pkg_name).ok();
134+
if let Some(ref prev) = prev_output {
135+
let val = (output_file.clone(), prev.rerun_if_changed.clone());
136+
cx.build_explicit_deps.insert(*unit, val);
137+
}
138+
127139
try!(fs::create_dir_all(&cx.layout(unit.pkg, Kind::Host).build(unit.pkg)));
128140
try!(fs::create_dir_all(&cx.layout(unit.pkg, unit.kind).build(unit.pkg)));
129141

@@ -177,8 +189,7 @@ fn build_work(cx: &mut Context, unit: &Unit) -> CargoResult<(Work, Work)> {
177189
pkg_name, e.desc);
178190
Human(e)
179191
}));
180-
try!(paths::write(&build_output.parent().unwrap().join("output"),
181-
&output.stdout));
192+
try!(paths::write(&output_file, &output.stdout));
182193

183194
// After the build command has finished running, we need to be sure to
184195
// remember all of its output so we can later discover precisely what it
@@ -199,10 +210,11 @@ fn build_work(cx: &mut Context, unit: &Unit) -> CargoResult<(Work, Work)> {
199210
// itself to run when we actually end up just discarding what we calculated
200211
// above.
201212
let fresh = Work::new(move |_tx| {
202-
let (id, pkg_name, build_state, build_output) = all;
203-
let contents = try!(paths::read(&build_output.parent().unwrap()
204-
.join("output")));
205-
let output = try!(BuildOutput::parse(&contents, &pkg_name));
213+
let (id, pkg_name, build_state, output_file) = all;
214+
let output = match prev_output {
215+
Some(output) => output,
216+
None => try!(BuildOutput::parse_file(&output_file, &pkg_name)),
217+
};
206218
build_state.insert(id, kind, output);
207219
Ok(())
208220
});
@@ -242,13 +254,19 @@ impl BuildState {
242254
}
243255

244256
impl BuildOutput {
257+
pub fn parse_file(path: &Path, pkg_name: &str) -> CargoResult<BuildOutput> {
258+
let contents = try!(paths::read(path));
259+
BuildOutput::parse(&contents, pkg_name)
260+
}
261+
245262
// Parses the output of a script.
246263
// The `pkg_name` is used for error messages.
247264
pub fn parse(input: &str, pkg_name: &str) -> CargoResult<BuildOutput> {
248265
let mut library_paths = Vec::new();
249266
let mut library_links = Vec::new();
250267
let mut cfgs = Vec::new();
251268
let mut metadata = Vec::new();
269+
let mut rerun_if_changed = Vec::new();
252270
let whence = format!("build script of `{}`", pkg_name);
253271

254272
for line in input.lines() {
@@ -283,6 +301,7 @@ impl BuildOutput {
283301
"rustc-link-lib" => library_links.push(value.to_string()),
284302
"rustc-link-search" => library_paths.push(PathBuf::from(value)),
285303
"rustc-cfg" => cfgs.push(value.to_string()),
304+
"rerun-if-changed" => rerun_if_changed.push(value.to_string()),
286305
_ => metadata.push((key.to_string(), value.to_string())),
287306
}
288307
}
@@ -292,6 +311,7 @@ impl BuildOutput {
292311
library_links: library_links,
293312
cfgs: cfgs,
294313
metadata: metadata,
314+
rerun_if_changed: rerun_if_changed,
295315
})
296316
}
297317

‎src/cargo/ops/cargo_rustc/fingerprint.rs

+48-12
Original file line numberDiff line numberDiff line change
@@ -124,7 +124,7 @@ impl Fingerprint {
124124
match self.local {
125125
LocalFingerprint::MtimeBased(ref slot, ref path) => {
126126
let mut slot = slot.0.lock().unwrap();
127-
if force || slot.is_none() {
127+
if force {
128128
let meta = try!(fs::metadata(path).chain_error(|| {
129129
internal(format!("failed to stat {:?}", path))
130130
}));
@@ -316,12 +316,6 @@ fn calculate<'a, 'cfg>(cx: &mut Context<'a, 'cfg>, unit: &Unit<'a>)
316316
let local = if use_dep_info(unit) {
317317
let dep_info = dep_info_loc(cx, unit);
318318
let mtime = try!(calculate_target_mtime(&dep_info));
319-
320-
// if the mtime listed is not fresh, then remove the `dep_info` file to
321-
// ensure that future calls to `resolve()` won't work.
322-
if mtime.is_none() {
323-
let _ = fs::remove_file(&dep_info);
324-
}
325319
LocalFingerprint::MtimeBased(MtimeSlot(Mutex::new(mtime)), dep_info)
326320
} else {
327321
let fingerprint = try!(calculate_pkg_fingerprint(cx, unit.pkg));
@@ -382,14 +376,29 @@ pub fn prepare_build_cmd(cx: &mut Context, unit: &Unit)
382376
// is just a hash of what it was overridden with. Otherwise the fingerprint
383377
// is that of the entire package itself as we just consider everything as
384378
// input to the build script.
385-
let new_fingerprint = {
379+
let local = {
386380
let state = cx.build_state.outputs.lock().unwrap();
387381
match state.get(&(unit.pkg.package_id().clone(), unit.kind)) {
388382
Some(output) => {
389-
format!("overridden build state with hash: {}",
390-
util::hash_u64(output))
383+
let s = format!("overridden build state with hash: {}",
384+
util::hash_u64(output));
385+
LocalFingerprint::Precalculated(s)
386+
}
387+
None => {
388+
match cx.build_explicit_deps.get(unit) {
389+
Some(&(ref output, ref deps)) if deps.len() > 0 => {
390+
let mtime = try!(calculate_explicit_fingerprint(unit,
391+
output,
392+
deps));
393+
LocalFingerprint::MtimeBased(MtimeSlot(Mutex::new(mtime)),
394+
output.clone())
395+
}
396+
_ => {
397+
let s = try!(calculate_pkg_fingerprint(cx, unit.pkg));
398+
LocalFingerprint::Precalculated(s)
399+
}
400+
}
391401
}
392-
None => try!(calculate_pkg_fingerprint(cx, unit.pkg)),
393402
}
394403
};
395404
let new_fingerprint = Arc::new(Fingerprint {
@@ -398,7 +407,7 @@ pub fn prepare_build_cmd(cx: &mut Context, unit: &Unit)
398407
profile: 0,
399408
features: String::new(),
400409
deps: Vec::new(),
401-
local: LocalFingerprint::Precalculated(new_fingerprint),
410+
local: local,
402411
resolved: Mutex::new(None),
403412
});
404413

@@ -550,6 +559,33 @@ fn calculate_pkg_fingerprint(cx: &Context,
550559
source.fingerprint(pkg)
551560
}
552561

562+
fn calculate_explicit_fingerprint(unit: &Unit,
563+
output: &Path,
564+
deps: &[String])
565+
-> CargoResult<Option<FileTime>> {
566+
let meta = match fs::metadata(output) {
567+
Ok(meta) => meta,
568+
Err(..) => return Ok(None),
569+
};
570+
let mtime = FileTime::from_last_modification_time(&meta);
571+
572+
for path in deps.iter().map(|p| unit.pkg.root().join(p)) {
573+
let meta = match fs::metadata(&path) {
574+
Ok(meta) => meta,
575+
Err(..) => {
576+
info!("bs stale: {} -- missing", path.display());
577+
return Ok(None)
578+
}
579+
};
580+
let mtime2 = FileTime::from_last_modification_time(&meta);
581+
if mtime2 > mtime {
582+
info!("bs stale: {} -- {} vs {}", path.display(), mtime2, mtime);
583+
return Ok(None)
584+
}
585+
}
586+
Ok(Some(mtime))
587+
}
588+
553589
fn filename(unit: &Unit) -> String {
554590
let kind = match *unit.target.kind() {
555591
TargetKind::Lib(..) => "lib",

‎src/doc/build-script.md

+6
Original file line numberDiff line numberDiff line change
@@ -68,6 +68,12 @@ build script is for is built:
6868
* `rustc-cfg` indicates that the specified directive will be passed as a `--cfg`
6969
flag to the compiler. This is often useful for performing compile-time
7070
detection of various features.
71+
* `rerun-if-changed` is a path to a file or directory which indicates that the
72+
build script should be re-run if it changes (detected by a more-recent
73+
last-modified timestamp on the file). Normally build scripts are re-run if
74+
any file inside the crate root changes, but this can be used to scope changes
75+
to just a small set of files. If this path points to a directory the entire
76+
directory will be traversed for changes.
7177

7278
Any other element is a user-defined metadata that will be passed to
7379
dependencies. More information about this can be found in the [`links`][links]

‎tests/test_cargo_compile_custom_build.rs

+83-1
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,6 @@
1-
use std::fs::File;
1+
use std::fs::{self, File};
22
use std::io::prelude::*;
3+
use std::thread;
34

45
use support::{project, execs};
56
use support::{COMPILING, RUNNING, DOCTEST, FRESH, DOCUMENTING};
@@ -1707,3 +1708,84 @@ test!(changing_an_override_invalidates {
17071708
{running} `rustc [..] -L native=bar`
17081709
", compiling = COMPILING, running = RUNNING)));
17091710
});
1711+
1712+
test!(rebuild_only_on_explicit_paths {
1713+
let p = project("a")
1714+
.file("Cargo.toml", r#"
1715+
[project]
1716+
name = "a"
1717+
version = "0.5.0"
1718+
authors = []
1719+
build = "build.rs"
1720+
"#)
1721+
.file("src/lib.rs", "")
1722+
.file("build.rs", r#"
1723+
fn main() {
1724+
println!("cargo:rerun-if-changed=foo");
1725+
println!("cargo:rerun-if-changed=bar");
1726+
}
1727+
"#);
1728+
p.build();
1729+
1730+
assert_that(p.cargo("build").arg("-v"),
1731+
execs().with_status(0));
1732+
1733+
// files don't exist, so should always rerun if they don't exist
1734+
println!("run without");
1735+
assert_that(p.cargo("build").arg("-v"),
1736+
execs().with_status(0).with_stdout(&format!("\
1737+
{compiling} a v0.5.0 ([..])
1738+
{running} `[..]build-script-build[..]`
1739+
{running} `rustc src[..]lib.rs [..]`
1740+
", running = RUNNING, compiling = COMPILING)));
1741+
1742+
thread::sleep_ms(1000);
1743+
File::create(p.root().join("foo")).unwrap();
1744+
File::create(p.root().join("bar")).unwrap();
1745+
1746+
// now the exist, so run once, catch the mtime, then shouldn't run again
1747+
println!("run with");
1748+
assert_that(p.cargo("build").arg("-v"),
1749+
execs().with_status(0).with_stdout(&format!("\
1750+
{compiling} a v0.5.0 ([..])
1751+
{running} `[..]build-script-build[..]`
1752+
{running} `rustc src[..]lib.rs [..]`
1753+
", running = RUNNING, compiling = COMPILING)));
1754+
1755+
println!("run with2");
1756+
assert_that(p.cargo("build").arg("-v"),
1757+
execs().with_status(0).with_stdout(&format!("\
1758+
{fresh} a v0.5.0 ([..])
1759+
", fresh = FRESH)));
1760+
1761+
thread::sleep_ms(1000);
1762+
1763+
// random other files do not affect freshness
1764+
println!("run baz");
1765+
File::create(p.root().join("baz")).unwrap();
1766+
assert_that(p.cargo("build").arg("-v"),
1767+
execs().with_status(0).with_stdout(&format!("\
1768+
{fresh} a v0.5.0 ([..])
1769+
", fresh = FRESH)));
1770+
1771+
// but changing dependent files does
1772+
println!("run foo change");
1773+
File::create(p.root().join("foo")).unwrap();
1774+
assert_that(p.cargo("build").arg("-v"),
1775+
execs().with_status(0).with_stdout(&format!("\
1776+
{compiling} a v0.5.0 ([..])
1777+
{running} `[..]build-script-build[..]`
1778+
{running} `rustc src[..]lib.rs [..]`
1779+
", running = RUNNING, compiling = COMPILING)));
1780+
1781+
// .. as does deleting a file
1782+
println!("run foo delete");
1783+
fs::remove_file(p.root().join("bar")).unwrap();
1784+
assert_that(p.cargo("build").arg("-v"),
1785+
execs().with_status(0).with_stdout(&format!("\
1786+
{compiling} a v0.5.0 ([..])
1787+
{running} `[..]build-script-build[..]`
1788+
{running} `rustc src[..]lib.rs [..]`
1789+
", running = RUNNING, compiling = COMPILING)));
1790+
});
1791+

0 commit comments

Comments
 (0)