summaryrefslogtreecommitdiffstats
path: root/src/bootstrap/tarball.rs
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-17 12:02:58 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-17 12:02:58 +0000
commit698f8c2f01ea549d77d7dc3338a12e04c11057b9 (patch)
tree173a775858bd501c378080a10dca74132f05bc50 /src/bootstrap/tarball.rs
parentInitial commit. (diff)
downloadrustc-698f8c2f01ea549d77d7dc3338a12e04c11057b9.tar.xz
rustc-698f8c2f01ea549d77d7dc3338a12e04c11057b9.zip
Adding upstream version 1.64.0+dfsg1.upstream/1.64.0+dfsg1
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/bootstrap/tarball.rs')
-rw-r--r--src/bootstrap/tarball.rs374
1 files changed, 374 insertions, 0 deletions
diff --git a/src/bootstrap/tarball.rs b/src/bootstrap/tarball.rs
new file mode 100644
index 000000000..7b0c029c1
--- /dev/null
+++ b/src/bootstrap/tarball.rs
@@ -0,0 +1,374 @@
+use std::{
+ path::{Path, PathBuf},
+ process::Command,
+};
+
+use crate::builder::Builder;
+use crate::util::t;
+
+#[derive(Copy, Clone)]
+pub(crate) enum OverlayKind {
+ Rust,
+ LLVM,
+ Cargo,
+ Clippy,
+ Miri,
+ Rustfmt,
+ RustDemangler,
+ RLS,
+ RustAnalyzer,
+}
+
+impl OverlayKind {
+ fn legal_and_readme(&self) -> &[&str] {
+ match self {
+ OverlayKind::Rust => &["COPYRIGHT", "LICENSE-APACHE", "LICENSE-MIT", "README.md"],
+ OverlayKind::LLVM => {
+ &["src/llvm-project/llvm/LICENSE.TXT", "src/llvm-project/llvm/README.txt"]
+ }
+ OverlayKind::Cargo => &[
+ "src/tools/cargo/README.md",
+ "src/tools/cargo/LICENSE-MIT",
+ "src/tools/cargo/LICENSE-APACHE",
+ "src/tools/cargo/LICENSE-THIRD-PARTY",
+ ],
+ OverlayKind::Clippy => &[
+ "src/tools/clippy/README.md",
+ "src/tools/clippy/LICENSE-APACHE",
+ "src/tools/clippy/LICENSE-MIT",
+ ],
+ OverlayKind::Miri => &[
+ "src/tools/miri/README.md",
+ "src/tools/miri/LICENSE-APACHE",
+ "src/tools/miri/LICENSE-MIT",
+ ],
+ OverlayKind::Rustfmt => &[
+ "src/tools/rustfmt/README.md",
+ "src/tools/rustfmt/LICENSE-APACHE",
+ "src/tools/rustfmt/LICENSE-MIT",
+ ],
+ OverlayKind::RustDemangler => {
+ &["src/tools/rust-demangler/README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+ }
+ OverlayKind::RLS => &[
+ "src/tools/rls/README.md",
+ "src/tools/rls/LICENSE-APACHE",
+ "src/tools/rls/LICENSE-MIT",
+ ],
+ OverlayKind::RustAnalyzer => &[
+ "src/tools/rust-analyzer/README.md",
+ "src/tools/rust-analyzer/LICENSE-APACHE",
+ "src/tools/rust-analyzer/LICENSE-MIT",
+ ],
+ }
+ }
+
+ fn version(&self, builder: &Builder<'_>) -> String {
+ match self {
+ OverlayKind::Rust => builder.rust_version(),
+ OverlayKind::LLVM => builder.rust_version(),
+ OverlayKind::RustDemangler => builder.release_num("rust-demangler"),
+ OverlayKind::Cargo => {
+ builder.cargo_info.version(builder, &builder.release_num("cargo"))
+ }
+ OverlayKind::Clippy => {
+ builder.clippy_info.version(builder, &builder.release_num("clippy"))
+ }
+ OverlayKind::Miri => builder.miri_info.version(builder, &builder.release_num("miri")),
+ OverlayKind::Rustfmt => {
+ builder.rustfmt_info.version(builder, &builder.release_num("rustfmt"))
+ }
+ OverlayKind::RLS => builder.rls_info.version(builder, &builder.release_num("rls")),
+ OverlayKind::RustAnalyzer => builder
+ .rust_analyzer_info
+ .version(builder, &builder.release_num("rust-analyzer/crates/rust-analyzer")),
+ }
+ }
+}
+
+pub(crate) struct Tarball<'a> {
+ builder: &'a Builder<'a>,
+
+ pkgname: String,
+ component: String,
+ target: Option<String>,
+ product_name: String,
+ overlay: OverlayKind,
+
+ temp_dir: PathBuf,
+ image_dir: PathBuf,
+ overlay_dir: PathBuf,
+ bulk_dirs: Vec<PathBuf>,
+
+ include_target_in_component_name: bool,
+ is_preview: bool,
+ permit_symlinks: bool,
+}
+
+impl<'a> Tarball<'a> {
+ pub(crate) fn new(builder: &'a Builder<'a>, component: &str, target: &str) -> Self {
+ Self::new_inner(builder, component, Some(target.into()))
+ }
+
+ pub(crate) fn new_targetless(builder: &'a Builder<'a>, component: &str) -> Self {
+ Self::new_inner(builder, component, None)
+ }
+
+ fn new_inner(builder: &'a Builder<'a>, component: &str, target: Option<String>) -> Self {
+ let pkgname = crate::dist::pkgname(builder, component);
+
+ let mut temp_dir = builder.out.join("tmp").join("tarball").join(component);
+ if let Some(target) = &target {
+ temp_dir = temp_dir.join(target);
+ }
+ let _ = std::fs::remove_dir_all(&temp_dir);
+
+ let image_dir = temp_dir.join("image");
+ let overlay_dir = temp_dir.join("overlay");
+
+ Self {
+ builder,
+
+ pkgname,
+ component: component.into(),
+ target,
+ product_name: "Rust".into(),
+ overlay: OverlayKind::Rust,
+
+ temp_dir,
+ image_dir,
+ overlay_dir,
+ bulk_dirs: Vec::new(),
+
+ include_target_in_component_name: false,
+ is_preview: false,
+ permit_symlinks: false,
+ }
+ }
+
+ pub(crate) fn set_overlay(&mut self, overlay: OverlayKind) {
+ self.overlay = overlay;
+ }
+
+ pub(crate) fn set_product_name(&mut self, name: &str) {
+ self.product_name = name.into();
+ }
+
+ pub(crate) fn include_target_in_component_name(&mut self, include: bool) {
+ self.include_target_in_component_name = include;
+ }
+
+ pub(crate) fn is_preview(&mut self, is: bool) {
+ self.is_preview = is;
+ }
+
+ pub(crate) fn permit_symlinks(&mut self, flag: bool) {
+ self.permit_symlinks = flag;
+ }
+
+ pub(crate) fn image_dir(&self) -> &Path {
+ t!(std::fs::create_dir_all(&self.image_dir));
+ &self.image_dir
+ }
+
+ pub(crate) fn add_file(&self, src: impl AsRef<Path>, destdir: impl AsRef<Path>, perms: u32) {
+ // create_dir_all fails to create `foo/bar/.`, so when the destination is "." this simply
+ // uses the base directory as the destination directory.
+ let destdir = if destdir.as_ref() == Path::new(".") {
+ self.image_dir.clone()
+ } else {
+ self.image_dir.join(destdir.as_ref())
+ };
+
+ t!(std::fs::create_dir_all(&destdir));
+ self.builder.install(src.as_ref(), &destdir, perms);
+ }
+
+ pub(crate) fn add_renamed_file(
+ &self,
+ src: impl AsRef<Path>,
+ destdir: impl AsRef<Path>,
+ new_name: &str,
+ ) {
+ let destdir = self.image_dir.join(destdir.as_ref());
+ t!(std::fs::create_dir_all(&destdir));
+ self.builder.copy(src.as_ref(), &destdir.join(new_name));
+ }
+
+ pub(crate) fn add_legal_and_readme_to(&self, destdir: impl AsRef<Path>) {
+ for file in self.overlay.legal_and_readme() {
+ self.add_file(self.builder.src.join(file), destdir.as_ref(), 0o644);
+ }
+ }
+
+ pub(crate) fn add_dir(&self, src: impl AsRef<Path>, dest: impl AsRef<Path>) {
+ let dest = self.image_dir.join(dest.as_ref());
+
+ t!(std::fs::create_dir_all(&dest));
+ self.builder.cp_r(src.as_ref(), &dest);
+ }
+
+ pub(crate) fn add_bulk_dir(&mut self, src: impl AsRef<Path>, dest: impl AsRef<Path>) {
+ self.bulk_dirs.push(dest.as_ref().to_path_buf());
+ self.add_dir(src, dest);
+ }
+
+ pub(crate) fn generate(self) -> GeneratedTarball {
+ let mut component_name = self.component.clone();
+ if self.is_preview {
+ component_name.push_str("-preview");
+ }
+ if self.include_target_in_component_name {
+ component_name.push('-');
+ component_name.push_str(
+ &self
+ .target
+ .as_ref()
+ .expect("include_target_in_component_name used in a targetless tarball"),
+ );
+ }
+
+ self.run(|this, cmd| {
+ cmd.arg("generate")
+ .arg("--image-dir")
+ .arg(&this.image_dir)
+ .arg(format!("--component-name={}", &component_name));
+
+ if let Some((dir, dirs)) = this.bulk_dirs.split_first() {
+ let mut arg = dir.as_os_str().to_os_string();
+ for dir in dirs {
+ arg.push(",");
+ arg.push(dir);
+ }
+ cmd.arg("--bulk-dirs").arg(&arg);
+ }
+
+ this.non_bare_args(cmd);
+ })
+ }
+
+ pub(crate) fn combine(self, tarballs: &[GeneratedTarball]) -> GeneratedTarball {
+ let mut input_tarballs = tarballs[0].path.as_os_str().to_os_string();
+ for tarball in &tarballs[1..] {
+ input_tarballs.push(",");
+ input_tarballs.push(&tarball.path);
+ }
+
+ self.run(|this, cmd| {
+ cmd.arg("combine").arg("--input-tarballs").arg(input_tarballs);
+ this.non_bare_args(cmd);
+ })
+ }
+
+ pub(crate) fn bare(self) -> GeneratedTarball {
+ // Bare tarballs should have the top level directory match the package
+ // name, not "image". We rename the image directory just before passing
+ // into rust-installer.
+ let dest = self.temp_dir.join(self.package_name());
+ t!(std::fs::rename(&self.image_dir, &dest));
+
+ self.run(|this, cmd| {
+ let distdir = crate::dist::distdir(this.builder);
+ t!(std::fs::create_dir_all(&distdir));
+ cmd.arg("tarball")
+ .arg("--input")
+ .arg(&dest)
+ .arg("--output")
+ .arg(distdir.join(this.package_name()));
+ })
+ }
+
+ fn package_name(&self) -> String {
+ if let Some(target) = &self.target {
+ format!("{}-{}", self.pkgname, target)
+ } else {
+ self.pkgname.clone()
+ }
+ }
+
+ fn non_bare_args(&self, cmd: &mut Command) {
+ cmd.arg("--rel-manifest-dir=rustlib")
+ .arg("--legacy-manifest-dirs=rustlib,cargo")
+ .arg(format!("--product-name={}", self.product_name))
+ .arg(format!("--success-message={} installed.", self.component))
+ .arg(format!("--package-name={}", self.package_name()))
+ .arg("--non-installed-overlay")
+ .arg(&self.overlay_dir)
+ .arg("--output-dir")
+ .arg(crate::dist::distdir(self.builder));
+ }
+
+ fn run(self, build_cli: impl FnOnce(&Tarball<'a>, &mut Command)) -> GeneratedTarball {
+ t!(std::fs::create_dir_all(&self.overlay_dir));
+ self.builder.create(&self.overlay_dir.join("version"), &self.overlay.version(self.builder));
+ if let Some(sha) = self.builder.rust_sha() {
+ self.builder.create(&self.overlay_dir.join("git-commit-hash"), &sha);
+ }
+ for file in self.overlay.legal_and_readme() {
+ self.builder.install(&self.builder.src.join(file), &self.overlay_dir, 0o644);
+ }
+
+ let mut cmd = self.builder.tool_cmd(crate::tool::Tool::RustInstaller);
+
+ let package_name = self.package_name();
+ self.builder.info(&format!("Dist {}", package_name));
+ let _time = crate::util::timeit(self.builder);
+
+ build_cli(&self, &mut cmd);
+ cmd.arg("--work-dir").arg(&self.temp_dir);
+ if let Some(formats) = &self.builder.config.dist_compression_formats {
+ assert!(!formats.is_empty(), "dist.compression-formats can't be empty");
+ cmd.arg("--compression-formats").arg(formats.join(","));
+ }
+ self.builder.run(&mut cmd);
+
+ // Ensure there are no symbolic links in the tarball. In particular,
+ // rustup-toolchain-install-master and most versions of Windows can't handle symbolic links.
+ let decompressed_output = self.temp_dir.join(&package_name);
+ if !self.builder.config.dry_run && !self.permit_symlinks {
+ for entry in walkdir::WalkDir::new(&decompressed_output) {
+ let entry = t!(entry);
+ if entry.path_is_symlink() {
+ panic!("generated a symlink in a tarball: {}", entry.path().display());
+ }
+ }
+ }
+
+ // Use either the first compression format defined, or "gz" as the default.
+ let ext = self
+ .builder
+ .config
+ .dist_compression_formats
+ .as_ref()
+ .and_then(|formats| formats.get(0))
+ .map(|s| s.as_str())
+ .unwrap_or("gz");
+
+ GeneratedTarball {
+ path: crate::dist::distdir(self.builder).join(format!("{}.tar.{}", package_name, ext)),
+ decompressed_output,
+ work: self.temp_dir,
+ }
+ }
+}
+
+#[derive(Debug, Clone)]
+pub struct GeneratedTarball {
+ path: PathBuf,
+ decompressed_output: PathBuf,
+ work: PathBuf,
+}
+
+impl GeneratedTarball {
+ pub(crate) fn tarball(&self) -> &Path {
+ &self.path
+ }
+
+ pub(crate) fn decompressed_output(&self) -> &Path {
+ &self.decompressed_output
+ }
+
+ pub(crate) fn work_dir(&self) -> &Path {
+ &self.work
+ }
+}