src/bootstrap/tarball.rs

   1 use std::{
   2     path::{Path, PathBuf},
   3     process::Command,
   4 };
   5
   6 use build_helper::t;
   7
   8 use crate::builder::Builder;
   9
  10 #[derive(Copy, Clone)]
  11 pub(crate) enum OverlayKind {
  12     Rust,
  13     LLVM,
  14     Cargo,
  15     Clippy,
  16     Miri,
  17     Rustfmt,
  18     RLS,
  19     RustAnalyzer,
  20 }
  21
  22 impl OverlayKind {
  23     fn legal_and_readme(&self) -> &[&str] {
  24         match self {
  25             OverlayKind::Rust => &["COPYRIGHT", "LICENSE-APACHE", "LICENSE-MIT", "README.md"],
  26             OverlayKind::LLVM => {
  27                 &["src/llvm-project/llvm/LICENSE.TXT", "src/llvm-project/llvm/README.txt"]
  28             }
  29             OverlayKind::Cargo => &[
  30                 "src/tools/cargo/README.md",
  31                 "src/tools/cargo/LICENSE-MIT",
  32                 "src/tools/cargo/LICENSE-APACHE",
  33                 "src/tools/cargo/LICENSE-THIRD-PARTY",
  34             ],
  35             OverlayKind::Clippy => &[
  36                 "src/tools/clippy/README.md",
  37                 "src/tools/clippy/LICENSE-APACHE",
  38                 "src/tools/clippy/LICENSE-MIT",
  39             ],
  40             OverlayKind::Miri => &[
  41                 "src/tools/miri/README.md",
  42                 "src/tools/miri/LICENSE-APACHE",
  43                 "src/tools/miri/LICENSE-MIT",
  44             ],
  45             OverlayKind::Rustfmt => &[
  46                 "src/tools/rustfmt/README.md",
  47                 "src/tools/rustfmt/LICENSE-APACHE",
  48                 "src/tools/rustfmt/LICENSE-MIT",
  49             ],
  50             OverlayKind::RLS => &[
  51                 "src/tools/rls/README.md",
  52                 "src/tools/rls/LICENSE-APACHE",
  53                 "src/tools/rls/LICENSE-MIT",
  54             ],
  55             OverlayKind::RustAnalyzer => &[
  56                 "src/tools/rust-analyzer/README.md",
  57                 "src/tools/rust-analyzer/LICENSE-APACHE",
  58                 "src/tools/rust-analyzer/LICENSE-MIT",
  59             ],
  60         }
  61     }
  62
  63     fn version(&self, builder: &Builder<'_>) -> String {
  64         match self {
  65             OverlayKind::Rust => builder.rust_version(),
  66             OverlayKind::LLVM => builder.rust_version(),
  67             OverlayKind::Cargo => {
  68                 builder.cargo_info.version(builder, &builder.release_num("cargo"))
  69             }
  70             OverlayKind::Clippy => {
  71                 builder.clippy_info.version(builder, &builder.release_num("clippy"))
  72             }
  73             OverlayKind::Miri => builder.miri_info.version(builder, &builder.release_num("miri")),
  74             OverlayKind::Rustfmt => {
  75                 builder.rustfmt_info.version(builder, &builder.release_num("rustfmt"))
  76             }
  77             OverlayKind::RLS => builder.rls_info.version(builder, &builder.release_num("rls")),
  78             OverlayKind::RustAnalyzer => builder
  79                 .rust_analyzer_info
  80                 .version(builder, &builder.release_num("rust-analyzer/crates/rust-analyzer")),
  81         }
  82     }
  83 }
  84
  85 pub(crate) struct Tarball<'a> {
  86     builder: &'a Builder<'a>,
  87
  88     pkgname: String,
  89     component: String,
  90     target: Option<String>,
  91     product_name: String,
  92     overlay: OverlayKind,
  93
  94     temp_dir: PathBuf,
  95     image_dir: PathBuf,
  96     overlay_dir: PathBuf,
  97
  98     include_target_in_component_name: bool,
  99     is_preview: bool,
 100     delete_temp_dir: bool,
 101 }
 102
 103 impl<'a> Tarball<'a> {
 104     pub(crate) fn new(builder: &'a Builder<'a>, component: &str, target: &str) -> Self {
 105         Self::new_inner(builder, component, Some(target.into()))
 106     }
 107
 108     pub(crate) fn new_targetless(builder: &'a Builder<'a>, component: &str) -> Self {
 109         Self::new_inner(builder, component, None)
 110     }
 111
 112     fn new_inner(builder: &'a Builder<'a>, component: &str, target: Option<String>) -> Self {
 113         let pkgname = crate::dist::pkgname(builder, component);
 114
 115         let mut temp_dir = builder.out.join("tmp").join("tarball").join(component);
 116         if let Some(target) = &target {
 117             temp_dir = temp_dir.join(target);
 118         }
 119         let _ = std::fs::remove_dir_all(&temp_dir);
 120
 121         let image_dir = temp_dir.join("image");
 122         let overlay_dir = temp_dir.join("overlay");
 123
 124         Self {
 125             builder,
 126
 127             pkgname,
 128             component: component.into(),
 129             target,
 130             product_name: "Rust".into(),
 131             overlay: OverlayKind::Rust,
 132
 133             temp_dir,
 134             image_dir,
 135             overlay_dir,
 136
 137             include_target_in_component_name: false,
 138             is_preview: false,
 139             delete_temp_dir: true,
 140         }
 141     }
 142
 143     pub(crate) fn set_overlay(&mut self, overlay: OverlayKind) {
 144         self.overlay = overlay;
 145     }
 146
 147     pub(crate) fn set_product_name(&mut self, name: &str) {
 148         self.product_name = name.into();
 149     }
 150
 151     pub(crate) fn include_target_in_component_name(&mut self, include: bool) {
 152         self.include_target_in_component_name = include;
 153     }
 154
 155     pub(crate) fn is_preview(&mut self, is: bool) {
 156         self.is_preview = is;
 157     }
 158
 159     pub(crate) fn image_dir(&self) -> &Path {
 160         t!(std::fs::create_dir_all(&self.image_dir));
 161         &self.image_dir
 162     }
 163
 164     pub(crate) fn add_file(&self, src: impl AsRef<Path>, destdir: impl AsRef<Path>, perms: u32) {
 165         // create_dir_all fails to create `foo/bar/.`, so when the destination is "." this simply
 166         // uses the base directory as the destination directory.
 167         let destdir = if destdir.as_ref() == Path::new(".") {
 168             self.image_dir.clone()
 169         } else {
 170             self.image_dir.join(destdir.as_ref())
 171         };
 172
 173         t!(std::fs::create_dir_all(&destdir));
 174         self.builder.install(src.as_ref(), &destdir, perms);
 175     }
 176
 177     pub(crate) fn add_renamed_file(
 178         &self,
 179         src: impl AsRef<Path>,
 180         destdir: impl AsRef<Path>,
 181         new_name: &str,
 182     ) {
 183         let destdir = self.image_dir.join(destdir.as_ref());
 184         t!(std::fs::create_dir_all(&destdir));
 185         self.builder.copy(src.as_ref(), &destdir.join(new_name));
 186     }
 187
 188     pub(crate) fn add_legal_and_readme_to(&self, destdir: impl AsRef<Path>) {
 189         for file in self.overlay.legal_and_readme() {
 190             self.add_file(self.builder.src.join(file), destdir.as_ref(), 0o644);
 191         }
 192     }
 193
 194     pub(crate) fn add_dir(&self, src: impl AsRef<Path>, dest: impl AsRef<Path>) {
 195         let dest = self.image_dir.join(dest.as_ref());
 196
 197         t!(std::fs::create_dir_all(&dest));
 198         self.builder.cp_r(src.as_ref(), &dest);
 199     }
 200
 201     pub(crate) fn persist_work_dir(&mut self) -> PathBuf {
 202         self.delete_temp_dir = false;
 203         self.temp_dir.clone()
 204     }
 205
 206     pub(crate) fn generate(self) -> PathBuf {
 207         let mut component_name = self.component.clone();
 208         if self.is_preview {
 209             component_name.push_str("-preview");
 210         }
 211         if self.include_target_in_component_name {
 212             component_name.push('-');
 213             component_name.push_str(
 214                 &self
 215                     .target
 216                     .as_ref()
 217                     .expect("include_target_in_component_name used in a targetless tarball"),
 218             );
 219         }
 220
 221         self.run(|this, cmd| {
 222             cmd.arg("generate")
 223                 .arg("--image-dir")
 224                 .arg(&this.image_dir)
 225                 .arg(format!("--component-name={}", &component_name));
 226             this.non_bare_args(cmd);
 227         })
 228     }
 229
 230     pub(crate) fn combine(self, tarballs: &[PathBuf]) {
 231         let mut input_tarballs = tarballs[0].as_os_str().to_os_string();
 232         for tarball in &tarballs[1..] {
 233             input_tarballs.push(",");
 234             input_tarballs.push(tarball);
 235         }
 236
 237         self.run(|this, cmd| {
 238             cmd.arg("combine").arg("--input-tarballs").arg(input_tarballs);
 239             this.non_bare_args(cmd);
 240         });
 241     }
 242
 243     pub(crate) fn bare(self) -> PathBuf {
 244         // Bare tarballs should have the top level directory match the package
 245         // name, not "image". We rename the image directory just before passing
 246         // into rust-installer.
 247         let dest = self.temp_dir.join(self.package_name());
 248         t!(std::fs::rename(&self.image_dir, &dest));
 249
 250         self.run(|this, cmd| {
 251             cmd.arg("tarball")
 252                 .arg("--input")
 253                 .arg(&dest)
 254                 .arg("--output")
 255                 .arg(crate::dist::distdir(this.builder).join(this.package_name()));
 256         })
 257     }
 258
 259     fn package_name(&self) -> String {
 260         if let Some(target) = &self.target {
 261             format!("{}-{}", self.pkgname, target)
 262         } else {
 263             self.pkgname.clone()
 264         }
 265     }
 266
 267     fn non_bare_args(&self, cmd: &mut Command) {
 268         cmd.arg("--rel-manifest-dir=rustlib")
 269             .arg("--legacy-manifest-dirs=rustlib,cargo")
 270             .arg(format!("--product-name={}", self.product_name))
 271             .arg(format!("--success-message={} installed.", self.component))
 272             .arg(format!("--package-name={}", self.package_name()))
 273             .arg("--non-installed-overlay")
 274             .arg(&self.overlay_dir)
 275             .arg("--output-dir")
 276             .arg(crate::dist::distdir(self.builder));
 277     }
 278
 279     fn run(self, build_cli: impl FnOnce(&Tarball<'a>, &mut Command)) -> PathBuf {
 280         t!(std::fs::create_dir_all(&self.overlay_dir));
 281         self.builder.create(&self.overlay_dir.join("version"), &self.overlay.version(self.builder));
 282         if let Some(sha) = self.builder.rust_sha() {
 283             self.builder.create(&self.overlay_dir.join("git-commit-hash"), &sha);
 284         }
 285         for file in self.overlay.legal_and_readme() {
 286             self.builder.install(&self.builder.src.join(file), &self.overlay_dir, 0o644);
 287         }
 288
 289         let mut cmd = self.builder.tool_cmd(crate::tool::Tool::RustInstaller);
 290
 291         let package_name = self.package_name();
 292         self.builder.info(&format!("Dist {}", package_name));
 293         let _time = crate::util::timeit(self.builder);
 294
 295         build_cli(&self, &mut cmd);
 296         cmd.arg("--work-dir").arg(&self.temp_dir);
 297         self.builder.run(&mut cmd);
 298         if self.delete_temp_dir {
 299             t!(std::fs::remove_dir_all(&self.temp_dir));
 300         }
 301
 302         crate::dist::distdir(self.builder).join(format!("{}.tar.gz", package_name))
 303     }
 304 }