src/bootstrap/install.rs

   1 // Copyright 2016 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 //! Implementation of the install aspects of the compiler.
  12 //!
  13 //! This module is responsible for installing the standard library,
  14 //! compiler, and documentation.
  15
  16 use std::env;
  17 use std::fs;
  18 use std::path::{Path, PathBuf, Component};
  19 use std::process::Command;
  20
  21 use dist::{self, pkgname, sanitize_sh, tmpdir};
  22
  23 use builder::{Builder, Step};
  24
  25 pub fn install_docs(builder: &Builder, stage: u32, host: &str) {
  26     install_sh(builder, "docs", "rust-docs", stage, Some(host));
  27 }
  28
  29 pub fn install_std(builder: &Builder, stage: u32) {
  30     for target in builder.build.config.target.iter() {
  31         install_sh(builder, "std", "rust-std", stage, Some(target));
  32     }
  33 }
  34
  35 pub fn install_cargo(builder: &Builder, stage: u32, host: &str) {
  36     install_sh(builder, "cargo", "cargo", stage, Some(host));
  37 }
  38
  39 pub fn install_rls(builder: &Builder, stage: u32, host: &str) {
  40     install_sh(builder, "rls", "rls", stage, Some(host));
  41 }
  42
  43 pub fn install_analysis(builder: &Builder, stage: u32, host: &str) {
  44     install_sh(builder, "analysis", "rust-analysis", stage, Some(host));
  45 }
  46
  47 pub fn install_src(builder: &Builder, stage: u32) {
  48     install_sh(builder, "src", "rust-src", stage, None);
  49 }
  50 pub fn install_rustc(builder: &Builder, stage: u32, host: &str) {
  51     install_sh(builder, "rustc", "rustc", stage, Some(host));
  52 }
  53
  54 fn install_sh(builder: &Builder, package: &str, name: &str, stage: u32, host: Option<&str>) {
  55     let build = builder.build;
  56     println!("Install {} stage{} ({:?})", package, stage, host);
  57
  58     let prefix_default = PathBuf::from("/usr/local");
  59     let sysconfdir_default = PathBuf::from("/etc");
  60     let docdir_default = PathBuf::from("share/doc/rust");
  61     let bindir_default = PathBuf::from("bin");
  62     let libdir_default = PathBuf::from("lib");
  63     let mandir_default = PathBuf::from("share/man");
  64     let prefix = build.config.prefix.as_ref().unwrap_or(&prefix_default);
  65     let sysconfdir = build.config.sysconfdir.as_ref().unwrap_or(&sysconfdir_default);
  66     let docdir = build.config.docdir.as_ref().unwrap_or(&docdir_default);
  67     let bindir = build.config.bindir.as_ref().unwrap_or(&bindir_default);
  68     let libdir = build.config.libdir.as_ref().unwrap_or(&libdir_default);
  69     let mandir = build.config.mandir.as_ref().unwrap_or(&mandir_default);
  70
  71     let sysconfdir = prefix.join(sysconfdir);
  72     let docdir = prefix.join(docdir);
  73     let bindir = prefix.join(bindir);
  74     let libdir = prefix.join(libdir);
  75     let mandir = prefix.join(mandir);
  76
  77     let destdir = env::var_os("DESTDIR").map(PathBuf::from);
  78
  79     let prefix = add_destdir(&prefix, &destdir);
  80     let sysconfdir = add_destdir(&sysconfdir, &destdir);
  81     let docdir = add_destdir(&docdir, &destdir);
  82     let bindir = add_destdir(&bindir, &destdir);
  83     let libdir = add_destdir(&libdir, &destdir);
  84     let mandir = add_destdir(&mandir, &destdir);
  85
  86     let empty_dir = build.out.join("tmp/empty_dir");
  87
  88     t!(fs::create_dir_all(&empty_dir));
  89     let package_name = if let Some(host) = host {
  90         format!("{}-{}", pkgname(build, name), host)
  91     } else {
  92         pkgname(build, name)
  93     };
  94
  95     let mut cmd = Command::new("sh");
  96     cmd.current_dir(&empty_dir)
  97         .arg(sanitize_sh(&tmpdir(build).join(&package_name).join("install.sh")))
  98         .arg(format!("--prefix={}", sanitize_sh(&prefix)))
  99         .arg(format!("--sysconfdir={}", sanitize_sh(&sysconfdir)))
 100         .arg(format!("--docdir={}", sanitize_sh(&docdir)))
 101         .arg(format!("--bindir={}", sanitize_sh(&bindir)))
 102         .arg(format!("--libdir={}", sanitize_sh(&libdir)))
 103         .arg(format!("--mandir={}", sanitize_sh(&mandir)))
 104         .arg("--disable-ldconfig");
 105     build.run(&mut cmd);
 106     t!(fs::remove_dir_all(&empty_dir));
 107 }
 108
 109 fn add_destdir(path: &Path, destdir: &Option<PathBuf>) -> PathBuf {
 110     let mut ret = match *destdir {
 111         Some(ref dest) => dest.clone(),
 112         None => return path.to_path_buf(),
 113     };
 114     for part in path.components() {
 115         match part {
 116             Component::Normal(s) => ret.push(s),
 117             _ => {}
 118         }
 119     }
 120     ret
 121 }
 122
 123 macro_rules! install {
 124     (($sel:ident, $builder:ident),
 125        $($name:ident,
 126        $path:expr,
 127        $default_cond:expr,
 128        only_hosts: $only_hosts:expr,
 129        $run_item:block $(, $c:ident)*;)+) => {
 130         $(#[derive(Serialize)]
 131         pub struct $name<'a> {
 132             pub stage: u32,
 133             pub target: &'a str,
 134             pub host: &'a str,
 135         }
 136
 137         impl<'a> Step<'a> for $name<'a> {
 138             type Output = ();
 139             const DEFAULT: bool = true;
 140             const ONLY_BUILD_TARGETS: bool = true;
 141             const ONLY_HOSTS: bool = $only_hosts;
 142             $(const $c: bool = true;)*
 143
 144             fn should_run(_builder: &Builder, path: &Path) -> bool {
 145                 path.ends_with($path)
 146             }
 147
 148             fn make_run($builder: &Builder, path: Option<&Path>, host: &str, target: &str) {
 149                 if path.is_none() && !($default_cond) {
 150                     return;
 151                 }
 152                 $builder.ensure($name {
 153                     stage: $builder.top_stage,
 154                     target,
 155                     host,
 156                 });
 157             }
 158
 159             fn run($sel, $builder: &Builder) {
 160                 $run_item
 161             }
 162         })+
 163     }
 164 }
 165
 166 install!((self, builder),
 167     // rules.install("install-docs", "src/doc")
 168     //      .default(build.config.docs)
 169     //      .only_host_build(true)
 170     //      .dep(|s| s.name("dist-docs"))
 171     //      .run(move |s| install::Installer::new(build).install_docs(s.stage, s.target));
 172     Docs, "src/doc", builder.build.config.docs, only_hosts: false, {
 173         builder.ensure(dist::Docs { stage: self.stage, target: self.target });
 174         install_docs(builder, self.stage, self.target);
 175     };
 176     // rules.install("install-std", "src/libstd")
 177     //      .default(true)
 178     //      .only_host_build(true)
 179     //      .dep(|s| s.name("dist-std"))
 180     //      .run(move |s| install::Installer::new(build).install_std(s.stage));
 181     Std, "src/libstd", true, only_hosts: true, {
 182         builder.ensure(dist::Std {
 183             compiler: builder.compiler(self.stage, self.host),
 184             target: self.target
 185         });
 186         install_std(builder, self.stage);
 187     };
 188     // rules.install("install-cargo", "cargo")
 189     //      .default(build.config.extended)
 190     //      .host(true)
 191     //      .only_host_build(true)
 192     //      .dep(|s| s.name("dist-cargo"))
 193     //      .run(move |s| install::Installer::new(build).install_cargo(s.stage, s.target));
 194     Cargo, "cargo", builder.build.config.extended, only_hosts: true, {
 195         builder.ensure(dist::Cargo { stage: self.stage, target: self.target });
 196         install_cargo(builder, self.stage, self.target);
 197     };
 198     // rules.install("install-rls", "rls")
 199     //      .default(build.config.extended)
 200     //      .host(true)
 201     //      .only_host_build(true)
 202     //      .dep(|s| s.name("dist-rls"))
 203     //      .run(move |s| install::Installer::new(build).install_rls(s.stage, s.target));
 204     Rls, "rls", builder.build.config.extended, only_hosts: true, {
 205         builder.ensure(dist::Rls { stage: self.stage, target: self.target });
 206         install_rls(builder, self.stage, self.target);
 207     };
 208     // rules.install("install-analysis", "analysis")
 209     //      .default(build.config.extended)
 210     //      .only_host_build(true)
 211     //      .dep(|s| s.name("dist-analysis"))
 212     //      .run(move |s| install::Installer::new(build).install_analysis(s.stage, s.target));
 213     Analysis, "analysis", builder.build.config.extended, only_hosts: false, {
 214         builder.ensure(dist::Analysis {
 215             compiler: builder.compiler(self.stage, self.host),
 216             target: self.target
 217         });
 218         install_analysis(builder, self.stage, self.target);
 219     };
 220     // rules.install("install-src", "src")
 221     //      .default(build.config.extended)
 222     //      .host(true)
 223     //      .only_build(true)
 224     //      .only_host_build(true)
 225     //      .dep(|s| s.name("dist-src"))
 226     //      .run(move |s| install::Installer::new(build).install_src(s.stage));
 227     Src, "src", builder.build.config.extended, only_hosts: true, {
 228         builder.ensure(dist::Src);
 229         install_src(builder, self.stage);
 230     }, ONLY_BUILD;
 231     // rules.install("install-rustc", "src/librustc")
 232     //      .default(true)
 233     //      .host(true)
 234     //      .only_host_build(true)
 235     //      .dep(|s| s.name("dist-rustc"))
 236     //      .run(move |s| install::Installer::new(build).install_rustc(s.stage, s.target));
 237     Rustc, "src/librustc", builder.build.config.extended, only_hosts: true, {
 238         builder.ensure(dist::Rustc { stage: self.stage, target: self.target });
 239         install_rustc(builder, self.stage, self.target);
 240     };
 241 );