src/bootstrap/tarball.rs

   1 use std::{
   2     path::{Path, PathBuf},
   3     process::Command,
   4 };
   5
   6 use crate::builder::Builder;
   7 use crate::util::t;
   8
   9 #[derive(Copy, Clone)]
  10 pub(crate) enum OverlayKind {
  11     Rust,
  12     LLVM,
  13     Cargo,
  14     Clippy,
  15     Miri,
  16     Rustfmt,
  17     RustDemangler,
  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::RustDemangler => {
  51                 &["src/tools/rust-demangler/README.md", "LICENSE-APACHE", "LICENSE-MIT"]
  52             }
  53             OverlayKind::RLS => &[
  54                 "src/tools/rls/README.md",
  55                 "src/tools/rls/LICENSE-APACHE",
  56                 "src/tools/rls/LICENSE-MIT",
  57             ],
  58             OverlayKind::RustAnalyzer => &[
  59                 "src/tools/rust-analyzer/README.md",
  60                 "src/tools/rust-analyzer/LICENSE-APACHE",
  61                 "src/tools/rust-analyzer/LICENSE-MIT",
  62             ],
  63         }
  64     }
  65
  66     fn version(&self, builder: &Builder<'_>) -> String {
  67         match self {
  68             OverlayKind::Rust => builder.rust_version(),
  69             OverlayKind::LLVM => builder.rust_version(),
  70             OverlayKind::RustDemangler => builder.release_num("rust-demangler"),
  71             OverlayKind::Cargo => {
  72                 builder.cargo_info.version(builder, &builder.release_num("cargo"))
  73             }
  74             OverlayKind::Clippy => {
  75                 builder.clippy_info.version(builder, &builder.release_num("clippy"))
  76             }
  77             OverlayKind::Miri => builder.miri_info.version(builder, &builder.release_num("miri")),
  78             OverlayKind::Rustfmt => {
  79                 builder.rustfmt_info.version(builder, &builder.release_num("rustfmt"))
  80             }
  81             OverlayKind::RLS => builder.rls_info.version(builder, &builder.release_num("rls")),
  82             OverlayKind::RustAnalyzer => builder
  83                 .rust_analyzer_info
  84                 .version(builder, &builder.release_num("rust-analyzer/crates/rust-analyzer")),
  85         }
  86     }
  87 }
  88
  89 pub(crate) struct Tarball<'a> {
  90     builder: &'a Builder<'a>,
  91
  92     pkgname: String,
  93     component: String,
  94     target: Option<String>,
  95     product_name: String,
  96     overlay: OverlayKind,
  97
  98     temp_dir: PathBuf,
  99     image_dir: PathBuf,
 100     overlay_dir: PathBuf,
 101     bulk_dirs: Vec<PathBuf>,
 102
 103     include_target_in_component_name: bool,
 104     is_preview: bool,
 105     permit_symlinks: bool,
 106 }
 107
 108 impl<'a> Tarball<'a> {
 109     pub(crate) fn new(builder: &'a Builder<'a>, component: &str, target: &str) -> Self {
 110         Self::new_inner(builder, component, Some(target.into()))
 111     }
 112
 113     pub(crate) fn new_targetless(builder: &'a Builder<'a>, component: &str) -> Self {
 114         Self::new_inner(builder, component, None)
 115     }
 116
 117     fn new_inner(builder: &'a Builder<'a>, component: &str, target: Option<String>) -> Self {
 118         let pkgname = crate::dist::pkgname(builder, component);
 119
 120         let mut temp_dir = builder.out.join("tmp").join("tarball").join(component);
 121         if let Some(target) = &target {
 122             temp_dir = temp_dir.join(target);
 123         }
 124         let _ = std::fs::remove_dir_all(&temp_dir);
 125
 126         let image_dir = temp_dir.join("image");
 127         let overlay_dir = temp_dir.join("overlay");
 128
 129         Self {
 130             builder,
 131
 132             pkgname,
 133             component: component.into(),
 134             target,
 135             product_name: "Rust".into(),
 136             overlay: OverlayKind::Rust,
 137
 138             temp_dir,
 139             image_dir,
 140             overlay_dir,
 141             bulk_dirs: Vec::new(),
 142
 143             include_target_in_component_name: false,
 144             is_preview: false,
 145             permit_symlinks: false,
 146         }
 147     }
 148
 149     pub(crate) fn set_overlay(&mut self, overlay: OverlayKind) {
 150         self.overlay = overlay;
 151     }
 152
 153     pub(crate) fn set_product_name(&mut self, name: &str) {
 154         self.product_name = name.into();
 155     }
 156
 157     pub(crate) fn include_target_in_component_name(&mut self, include: bool) {
 158         self.include_target_in_component_name = include;
 159     }
 160
 161     pub(crate) fn is_preview(&mut self, is: bool) {
 162         self.is_preview = is;
 163     }
 164
 165     pub(crate) fn permit_symlinks(&mut self, flag: bool) {
 166         self.permit_symlinks = flag;
 167     }
 168
 169     pub(crate) fn image_dir(&self) -> &Path {
 170         t!(std::fs::create_dir_all(&self.image_dir));
 171         &self.image_dir
 172     }
 173
 174     pub(crate) fn add_file(&self, src: impl AsRef<Path>, destdir: impl AsRef<Path>, perms: u32) {
 175         // create_dir_all fails to create `foo/bar/.`, so when the destination is "." this simply
 176         // uses the base directory as the destination directory.
 177         let destdir = if destdir.as_ref() == Path::new(".") {
 178             self.image_dir.clone()
 179         } else {
 180             self.image_dir.join(destdir.as_ref())
 181         };
 182
 183         t!(std::fs::create_dir_all(&destdir));
 184         self.builder.install(src.as_ref(), &destdir, perms);
 185     }
 186
 187     pub(crate) fn add_renamed_file(
 188         &self,
 189         src: impl AsRef<Path>,
 190         destdir: impl AsRef<Path>,
 191         new_name: &str,
 192     ) {
 193         let destdir = self.image_dir.join(destdir.as_ref());
 194         t!(std::fs::create_dir_all(&destdir));
 195         self.builder.copy(src.as_ref(), &destdir.join(new_name));
 196     }
 197
 198     pub(crate) fn add_legal_and_readme_to(&self, destdir: impl AsRef<Path>) {
 199         for file in self.overlay.legal_and_readme() {
 200             self.add_file(self.builder.src.join(file), destdir.as_ref(), 0o644);
 201         }
 202     }
 203
 204     pub(crate) fn add_dir(&self, src: impl AsRef<Path>, dest: impl AsRef<Path>) {
 205         let dest = self.image_dir.join(dest.as_ref());
 206
 207         t!(std::fs::create_dir_all(&dest));
 208         self.builder.cp_r(src.as_ref(), &dest);
 209     }
 210
 211     pub(crate) fn add_bulk_dir(&mut self, src: impl AsRef<Path>, dest: impl AsRef<Path>) {
 212         self.bulk_dirs.push(dest.as_ref().to_path_buf());
 213         self.add_dir(src, dest);
 214     }
 215
 216     pub(crate) fn generate(self) -> GeneratedTarball {
 217         let mut component_name = self.component.clone();
 218         if self.is_preview {
 219             component_name.push_str("-preview");
 220         }
 221         if self.include_target_in_component_name {
 222             component_name.push('-');
 223             component_name.push_str(
 224                 &self
 225                     .target
 226                     .as_ref()
 227                     .expect("include_target_in_component_name used in a targetless tarball"),
 228             );
 229         }
 230
 231         self.run(|this, cmd| {
 232             cmd.arg("generate")
 233                 .arg("--image-dir")
 234                 .arg(&this.image_dir)
 235                 .arg(format!("--component-name={}", &component_name));
 236
 237             if let Some((dir, dirs)) = this.bulk_dirs.split_first() {
 238                 let mut arg = dir.as_os_str().to_os_string();
 239                 for dir in dirs {
 240                     arg.push(",");
 241                     arg.push(dir);
 242                 }
 243                 cmd.arg("--bulk-dirs").arg(&arg);
 244             }
 245
 246             this.non_bare_args(cmd);
 247         })
 248     }
 249
 250     pub(crate) fn combine(self, tarballs: &[GeneratedTarball]) -> GeneratedTarball {
 251         let mut input_tarballs = tarballs[0].path.as_os_str().to_os_string();
 252         for tarball in &tarballs[1..] {
 253             input_tarballs.push(",");
 254             input_tarballs.push(&tarball.path);
 255         }
 256
 257         self.run(|this, cmd| {
 258             cmd.arg("combine").arg("--input-tarballs").arg(input_tarballs);
 259             this.non_bare_args(cmd);
 260         })
 261     }
 262
 263     pub(crate) fn bare(self) -> GeneratedTarball {
 264         // Bare tarballs should have the top level directory match the package
 265         // name, not "image". We rename the image directory just before passing
 266         // into rust-installer.
 267         let dest = self.temp_dir.join(self.package_name());
 268         t!(std::fs::rename(&self.image_dir, &dest));
 269
 270         self.run(|this, cmd| {
 271             let distdir = crate::dist::distdir(this.builder);
 272             t!(std::fs::create_dir_all(&distdir));
 273             cmd.arg("tarball")
 274                 .arg("--input")
 275                 .arg(&dest)
 276                 .arg("--output")
 277                 .arg(distdir.join(this.package_name()));
 278         })
 279     }
 280
 281     fn package_name(&self) -> String {
 282         if let Some(target) = &self.target {
 283             format!("{}-{}", self.pkgname, target)
 284         } else {
 285             self.pkgname.clone()
 286         }
 287     }
 288
 289     fn non_bare_args(&self, cmd: &mut Command) {
 290         cmd.arg("--rel-manifest-dir=rustlib")
 291             .arg("--legacy-manifest-dirs=rustlib,cargo")
 292             .arg(format!("--product-name={}", self.product_name))
 293             .arg(format!("--success-message={} installed.", self.component))
 294             .arg(format!("--package-name={}", self.package_name()))
 295             .arg("--non-installed-overlay")
 296             .arg(&self.overlay_dir)
 297             .arg("--output-dir")
 298             .arg(crate::dist::distdir(self.builder));
 299     }
 300
 301     fn run(self, build_cli: impl FnOnce(&Tarball<'a>, &mut Command)) -> GeneratedTarball {
 302         t!(std::fs::create_dir_all(&self.overlay_dir));
 303         self.builder.create(&self.overlay_dir.join("version"), &self.overlay.version(self.builder));
 304         if let Some(sha) = self.builder.rust_sha() {
 305             self.builder.create(&self.overlay_dir.join("git-commit-hash"), &sha);
 306         }
 307         for file in self.overlay.legal_and_readme() {
 308             self.builder.install(&self.builder.src.join(file), &self.overlay_dir, 0o644);
 309         }
 310
 311         let mut cmd = self.builder.tool_cmd(crate::tool::Tool::RustInstaller);
 312
 313         let package_name = self.package_name();
 314         self.builder.info(&format!("Dist {}", package_name));
 315         let _time = crate::util::timeit(self.builder);
 316
 317         build_cli(&self, &mut cmd);
 318         cmd.arg("--work-dir").arg(&self.temp_dir);
 319         if let Some(formats) = &self.builder.config.dist_compression_formats {
 320             assert!(!formats.is_empty(), "dist.compression-formats can't be empty");
 321             cmd.arg("--compression-formats").arg(formats.join(","));
 322         }
 323         self.builder.run(&mut cmd);
 324
 325         // Ensure there are no symbolic links in the tarball. In particular,
 326         // rustup-toolchain-install-master and most versions of Windows can't handle symbolic links.
 327         let decompressed_output = self.temp_dir.join(&package_name);
 328         if !self.builder.config.dry_run && !self.permit_symlinks {
 329             for entry in walkdir::WalkDir::new(&decompressed_output) {
 330                 let entry = t!(entry);
 331                 if entry.path_is_symlink() {
 332                     panic!("generated a symlink in a tarball: {}", entry.path().display());
 333                 }
 334             }
 335         }
 336
 337         // Use either the first compression format defined, or "gz" as the default.
 338         let ext = self
 339             .builder
 340             .config
 341             .dist_compression_formats
 342             .as_ref()
 343             .and_then(|formats| formats.get(0))
 344             .map(|s| s.as_str())
 345             .unwrap_or("gz");
 346
 347         GeneratedTarball {
 348             path: crate::dist::distdir(self.builder).join(format!("{}.tar.{}", package_name, ext)),
 349             decompressed_output,
 350             work: self.temp_dir,
 351         }
 352     }
 353 }
 354
 355 #[derive(Debug, Clone)]
 356 pub struct GeneratedTarball {
 357     path: PathBuf,
 358     decompressed_output: PathBuf,
 359     work: PathBuf,
 360 }
 361
 362 impl GeneratedTarball {
 363     pub(crate) fn tarball(&self) -> &Path {
 364         &self.path
 365     }
 366
 367     pub(crate) fn decompressed_output(&self) -> &Path {
 368         &self.decompressed_output
 369     }
 370
 371     pub(crate) fn work_dir(&self) -> &Path {
 372         &self.work
 373     }
 374 }