d78063dd84
Right now if you configure multiple hosts rustbuild will only build documentation for the build triple, but we've got all the support necessary to build documentation for different architectures as well. This commit reinterprets the `target` field of doc `Step` instances to be the target of the documentation rather than the target of the rustdoc/tool being run. This should enable `make dist` to start producing a bunch of `rust-docs` packages for all the cross architectures that rustbuild is producing now.
293 lines
11 KiB
Rust
293 lines
11 KiB
Rust
// Copyright 2016 The Rust Project Developers. See the COPYRIGHT
|
|
// file at the top-level directory of this distribution and at
|
|
// http://rust-lang.org/COPYRIGHT.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
|
|
use std::fs::{self, File};
|
|
use std::io::Write;
|
|
use std::path::{PathBuf, Path};
|
|
use std::process::Command;
|
|
|
|
use build::{Build, Compiler};
|
|
use build::util::{cp_r, libdir, is_dylib};
|
|
|
|
fn package_vers(build: &Build) -> &str {
|
|
match &build.config.channel[..] {
|
|
"stable" => &build.release,
|
|
"beta" => "beta",
|
|
"nightly" => "nightly",
|
|
_ => &build.release,
|
|
}
|
|
}
|
|
|
|
fn distdir(build: &Build) -> PathBuf {
|
|
build.out.join("dist")
|
|
}
|
|
|
|
fn tmpdir(build: &Build) -> PathBuf {
|
|
build.out.join("tmp/dist")
|
|
}
|
|
|
|
pub fn docs(build: &Build, stage: u32, host: &str) {
|
|
println!("Dist docs stage{} ({})", stage, host);
|
|
let name = format!("rust-docs-{}", package_vers(build));
|
|
let image = tmpdir(build).join(format!("{}-{}-image", name, name));
|
|
let _ = fs::remove_dir_all(&image);
|
|
|
|
let dst = image.join("share/doc/rust/html");
|
|
t!(fs::create_dir_all(&dst));
|
|
let src = build.out.join(host).join("doc");
|
|
cp_r(&src, &dst);
|
|
|
|
let mut cmd = Command::new("sh");
|
|
cmd.arg(sanitize_sh(&build.src.join("src/rust-installer/gen-installer.sh")))
|
|
.arg("--product-name=Rust-Documentation")
|
|
.arg("--rel-manifest-dir=rustlib")
|
|
.arg("--success-message=Rust-documentation-is-installed.")
|
|
.arg(format!("--image-dir={}", sanitize_sh(&image)))
|
|
.arg(format!("--work-dir={}", sanitize_sh(&tmpdir(build))))
|
|
.arg(format!("--output-dir={}", sanitize_sh(&distdir(build))))
|
|
.arg(format!("--package-name={}-{}", name, host))
|
|
.arg("--component-name=rust-docs")
|
|
.arg("--legacy-manifest-dirs=rustlib,cargo")
|
|
.arg("--bulk-dirs=share/doc/rust/html");
|
|
build.run(&mut cmd);
|
|
t!(fs::remove_dir_all(&image));
|
|
|
|
// As part of this step, *also* copy the docs directory to a directory which
|
|
// buildbot typically uploads.
|
|
if host == build.config.build {
|
|
let dst = distdir(build).join("doc").join(&build.package_vers);
|
|
t!(fs::create_dir_all(&dst));
|
|
cp_r(&src, &dst);
|
|
}
|
|
}
|
|
|
|
pub fn mingw(build: &Build, host: &str) {
|
|
println!("Dist mingw ({})", host);
|
|
let name = format!("rust-mingw-{}", package_vers(build));
|
|
let image = tmpdir(build).join(format!("{}-{}-image", name, host));
|
|
let _ = fs::remove_dir_all(&image);
|
|
|
|
// The first argument to the script is a "temporary directory" which is just
|
|
// thrown away (this contains the runtime DLLs included in the rustc package
|
|
// above) and the second argument is where to place all the MinGW components
|
|
// (which is what we want).
|
|
//
|
|
// FIXME: this script should be rewritten into Rust
|
|
let mut cmd = Command::new("python");
|
|
cmd.arg(build.src.join("src/etc/make-win-dist.py"))
|
|
.arg(tmpdir(build))
|
|
.arg(&image)
|
|
.arg(host);
|
|
build.run(&mut cmd);
|
|
|
|
let mut cmd = Command::new("sh");
|
|
cmd.arg(sanitize_sh(&build.src.join("src/rust-installer/gen-installer.sh")))
|
|
.arg("--product-name=Rust-MinGW")
|
|
.arg("--rel-manifest-dir=rustlib")
|
|
.arg("--success-message=Rust-MinGW-is-installed.")
|
|
.arg(format!("--image-dir={}", sanitize_sh(&image)))
|
|
.arg(format!("--work-dir={}", sanitize_sh(&tmpdir(build))))
|
|
.arg(format!("--output-dir={}", sanitize_sh(&distdir(build))))
|
|
.arg(format!("--package-name={}-{}", name, host))
|
|
.arg("--component-name=rust-mingw")
|
|
.arg("--legacy-manifest-dirs=rustlib,cargo");
|
|
build.run(&mut cmd);
|
|
t!(fs::remove_dir_all(&image));
|
|
}
|
|
|
|
pub fn rustc(build: &Build, stage: u32, host: &str) {
|
|
println!("Dist rustc stage{} ({})", stage, host);
|
|
let name = format!("rustc-{}", package_vers(build));
|
|
let image = tmpdir(build).join(format!("{}-{}-image", name, host));
|
|
let _ = fs::remove_dir_all(&image);
|
|
let overlay = tmpdir(build).join(format!("{}-{}-overlay", name, host));
|
|
let _ = fs::remove_dir_all(&overlay);
|
|
|
|
// Prepare the rustc "image", what will actually end up getting installed
|
|
prepare_image(build, stage, host, &image);
|
|
|
|
// Prepare the overlay which is part of the tarball but won't actually be
|
|
// installed
|
|
t!(fs::create_dir_all(&overlay));
|
|
let cp = |file: &str| {
|
|
install(&build.src.join(file), &overlay, 0o644);
|
|
};
|
|
cp("COPYRIGHT");
|
|
cp("LICENSE-APACHE");
|
|
cp("LICENSE-MIT");
|
|
cp("README.md");
|
|
// tiny morsel of metadata is used by rust-packaging
|
|
let version = &build.version;
|
|
t!(t!(File::create(overlay.join("version"))).write_all(version.as_bytes()));
|
|
|
|
// On MinGW we've got a few runtime DLL dependencies that we need to
|
|
// include. The first argument to this script is where to put these DLLs
|
|
// (the image we're creating), and the second argument is a junk directory
|
|
// to ignore all other MinGW stuff the script creates.
|
|
//
|
|
// On 32-bit MinGW we're always including a DLL which needs some extra
|
|
// licenses to distribute. On 64-bit MinGW we don't actually distribute
|
|
// anything requiring us to distribute a license, but it's likely the
|
|
// install will *also* include the rust-mingw package, which also needs
|
|
// licenses, so to be safe we just include it here in all MinGW packages.
|
|
//
|
|
// FIXME: this script should be rewritten into Rust
|
|
if host.contains("pc-windows-gnu") {
|
|
let mut cmd = Command::new("python");
|
|
cmd.arg(build.src.join("src/etc/make-win-dist.py"))
|
|
.arg(&image)
|
|
.arg(tmpdir(build))
|
|
.arg(host);
|
|
build.run(&mut cmd);
|
|
|
|
let dst = image.join("share/doc");
|
|
t!(fs::create_dir_all(&dst));
|
|
cp_r(&build.src.join("src/etc/third-party"), &dst);
|
|
}
|
|
|
|
// Finally, wrap everything up in a nice tarball!
|
|
let mut cmd = Command::new("sh");
|
|
cmd.arg(sanitize_sh(&build.src.join("src/rust-installer/gen-installer.sh")))
|
|
.arg("--product-name=Rust")
|
|
.arg("--rel-manifest-dir=rustlib")
|
|
.arg("--success-message=Rust-is-ready-to-roll.")
|
|
.arg(format!("--image-dir={}", sanitize_sh(&image)))
|
|
.arg(format!("--work-dir={}", sanitize_sh(&tmpdir(build))))
|
|
.arg(format!("--output-dir={}", sanitize_sh(&distdir(build))))
|
|
.arg(format!("--non-installed-overlay={}", sanitize_sh(&overlay)))
|
|
.arg(format!("--package-name={}-{}", name, host))
|
|
.arg("--component-name=rustc")
|
|
.arg("--legacy-manifest-dirs=rustlib,cargo");
|
|
build.run(&mut cmd);
|
|
t!(fs::remove_dir_all(&image));
|
|
t!(fs::remove_dir_all(&overlay));
|
|
|
|
fn prepare_image(build: &Build, stage: u32, host: &str, image: &Path) {
|
|
let src = build.sysroot(&Compiler::new(stage, host));
|
|
let libdir = libdir(host);
|
|
|
|
// Copy rustc/rustdoc binaries
|
|
t!(fs::create_dir_all(image.join("bin")));
|
|
cp_r(&src.join("bin"), &image.join("bin"));
|
|
|
|
// Copy runtime DLLs needed by the compiler
|
|
if libdir != "bin" {
|
|
t!(fs::create_dir_all(image.join(libdir)));
|
|
for entry in t!(src.join(libdir).read_dir()).map(|e| t!(e)) {
|
|
let name = entry.file_name();
|
|
if let Some(s) = name.to_str() {
|
|
if is_dylib(s) {
|
|
install(&entry.path(), &image.join(libdir), 0o644);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Man pages
|
|
t!(fs::create_dir_all(image.join("share/man/man1")));
|
|
cp_r(&build.src.join("man"), &image.join("share/man/man1"));
|
|
|
|
// Debugger scripts
|
|
let cp_debugger_script = |file: &str| {
|
|
let dst = image.join("lib/rustlib/etc");
|
|
t!(fs::create_dir_all(&dst));
|
|
install(&build.src.join("src/etc/").join(file), &dst, 0o644);
|
|
};
|
|
if host.contains("windows") {
|
|
// no debugger scripts
|
|
} else if host.contains("darwin") {
|
|
// lldb debugger scripts
|
|
install(&build.src.join("src/etc/rust-lldb"), &image.join("bin"),
|
|
0o755);
|
|
|
|
cp_debugger_script("lldb_rust_formatters.py");
|
|
cp_debugger_script("debugger_pretty_printers_common.py");
|
|
} else {
|
|
// gdb debugger scripts
|
|
install(&build.src.join("src/etc/rust-gdb"), &image.join("bin"),
|
|
0o755);
|
|
|
|
cp_debugger_script("gdb_load_rust_pretty_printers.py");
|
|
cp_debugger_script("gdb_rust_pretty_printing.py");
|
|
cp_debugger_script("debugger_pretty_printers_common.py");
|
|
}
|
|
|
|
// Misc license info
|
|
let cp = |file: &str| {
|
|
install(&build.src.join(file), &image.join("share/doc/rust"), 0o644);
|
|
};
|
|
t!(fs::create_dir_all(&image.join("share/doc/rust")));
|
|
cp("COPYRIGHT");
|
|
cp("LICENSE-APACHE");
|
|
cp("LICENSE-MIT");
|
|
cp("README.md");
|
|
}
|
|
}
|
|
|
|
pub fn std(build: &Build, compiler: &Compiler, target: &str) {
|
|
println!("Dist std stage{} ({} -> {})", compiler.stage, compiler.host,
|
|
target);
|
|
let name = format!("rust-std-{}", package_vers(build));
|
|
let image = tmpdir(build).join(format!("{}-{}-image", name, target));
|
|
let _ = fs::remove_dir_all(&image);
|
|
|
|
let dst = image.join("lib/rustlib").join(target);
|
|
t!(fs::create_dir_all(&dst));
|
|
let src = build.sysroot(compiler).join("lib/rustlib");
|
|
cp_r(&src.join(target), &dst);
|
|
|
|
let mut cmd = Command::new("sh");
|
|
cmd.arg(sanitize_sh(&build.src.join("src/rust-installer/gen-installer.sh")))
|
|
.arg("--product-name=Rust")
|
|
.arg("--rel-manifest-dir=rustlib")
|
|
.arg("--success-message=std-is-standing-at-the-ready.")
|
|
.arg(format!("--image-dir={}", sanitize_sh(&image)))
|
|
.arg(format!("--work-dir={}", sanitize_sh(&tmpdir(build))))
|
|
.arg(format!("--output-dir={}", sanitize_sh(&distdir(build))))
|
|
.arg(format!("--package-name={}-{}", name, target))
|
|
.arg(format!("--component-name=rust-std-{}", target))
|
|
.arg("--legacy-manifest-dirs=rustlib,cargo");
|
|
build.run(&mut cmd);
|
|
t!(fs::remove_dir_all(&image));
|
|
}
|
|
|
|
fn install(src: &Path, dstdir: &Path, perms: u32) {
|
|
let dst = dstdir.join(src.file_name().unwrap());
|
|
t!(fs::copy(src, &dst));
|
|
chmod(&dst, perms);
|
|
}
|
|
|
|
#[cfg(unix)]
|
|
fn chmod(path: &Path, perms: u32) {
|
|
use std::os::unix::fs::*;
|
|
t!(fs::set_permissions(path, fs::Permissions::from_mode(perms)));
|
|
}
|
|
#[cfg(windows)]
|
|
fn chmod(_path: &Path, _perms: u32) {}
|
|
|
|
// We have to run a few shell scripts, which choke quite a bit on both `\`
|
|
// characters and on `C:\` paths, so normalize both of them away.
|
|
fn sanitize_sh(path: &Path) -> String {
|
|
let path = path.to_str().unwrap().replace("\\", "/");
|
|
return change_drive(&path).unwrap_or(path);
|
|
|
|
fn change_drive(s: &str) -> Option<String> {
|
|
let mut ch = s.chars();
|
|
let drive = ch.next().unwrap_or('C');
|
|
if ch.next() != Some(':') {
|
|
return None
|
|
}
|
|
if ch.next() != Some('/') {
|
|
return None
|
|
}
|
|
Some(format!("/{}/{}", drive, &s[drive.len_utf8() + 2..]))
|
|
}
|
|
}
|