6 use crate::builder::Builder;
10 #[derive(Copy, Clone)]
11 pub(crate) enum OverlayKind {
24 fn legal_and_readme(&self) -> &[&str] {
26 OverlayKind::Rust => &["COPYRIGHT", "LICENSE-APACHE", "LICENSE-MIT", "README.md"],
27 OverlayKind::LLVM => {
28 &["src/llvm-project/llvm/LICENSE.TXT", "src/llvm-project/llvm/README.txt"]
30 OverlayKind::Cargo => &[
31 "src/tools/cargo/README.md",
32 "src/tools/cargo/LICENSE-MIT",
33 "src/tools/cargo/LICENSE-APACHE",
34 "src/tools/cargo/LICENSE-THIRD-PARTY",
36 OverlayKind::Clippy => &[
37 "src/tools/clippy/README.md",
38 "src/tools/clippy/LICENSE-APACHE",
39 "src/tools/clippy/LICENSE-MIT",
41 OverlayKind::Miri => &[
42 "src/tools/miri/README.md",
43 "src/tools/miri/LICENSE-APACHE",
44 "src/tools/miri/LICENSE-MIT",
46 OverlayKind::Rustfmt => &[
47 "src/tools/rustfmt/README.md",
48 "src/tools/rustfmt/LICENSE-APACHE",
49 "src/tools/rustfmt/LICENSE-MIT",
51 OverlayKind::RustDemangler => {
52 &["src/tools/rust-demangler/README.md", "LICENSE-APACHE", "LICENSE-MIT"]
54 OverlayKind::RLS => &["src/tools/rls/README.md", "LICENSE-APACHE", "LICENSE-MIT"],
55 OverlayKind::RustAnalyzer => &[
56 "src/tools/rust-analyzer/README.md",
57 "src/tools/rust-analyzer/LICENSE-APACHE",
58 "src/tools/rust-analyzer/LICENSE-MIT",
63 fn version(&self, builder: &Builder<'_>) -> String {
65 OverlayKind::Rust => builder.rust_version(),
66 OverlayKind::LLVM => builder.rust_version(),
67 OverlayKind::RustDemangler => builder.release_num("rust-demangler"),
68 OverlayKind::Cargo => {
69 builder.cargo_info.version(builder, &builder.release_num("cargo"))
71 OverlayKind::Clippy => {
72 builder.clippy_info.version(builder, &builder.release_num("clippy"))
74 OverlayKind::Miri => builder.miri_info.version(builder, &builder.release_num("miri")),
75 OverlayKind::Rustfmt => {
76 builder.rustfmt_info.version(builder, &builder.release_num("rustfmt"))
78 OverlayKind::RLS => builder.release(&builder.release_num("rls")),
79 OverlayKind::RustAnalyzer => builder
81 .version(builder, &builder.release_num("rust-analyzer/crates/rust-analyzer")),
86 pub(crate) struct Tarball<'a> {
87 builder: &'a Builder<'a>,
91 target: Option<String>,
98 bulk_dirs: Vec<PathBuf>,
100 include_target_in_component_name: bool,
102 permit_symlinks: bool,
105 impl<'a> Tarball<'a> {
106 pub(crate) fn new(builder: &'a Builder<'a>, component: &str, target: &str) -> Self {
107 Self::new_inner(builder, component, Some(target.into()))
110 pub(crate) fn new_targetless(builder: &'a Builder<'a>, component: &str) -> Self {
111 Self::new_inner(builder, component, None)
114 fn new_inner(builder: &'a Builder<'a>, component: &str, target: Option<String>) -> Self {
115 let pkgname = crate::dist::pkgname(builder, component);
117 let mut temp_dir = builder.out.join("tmp").join("tarball").join(component);
118 if let Some(target) = &target {
119 temp_dir = temp_dir.join(target);
121 let _ = std::fs::remove_dir_all(&temp_dir);
123 let image_dir = temp_dir.join("image");
124 let overlay_dir = temp_dir.join("overlay");
130 component: component.into(),
132 product_name: "Rust".into(),
133 overlay: OverlayKind::Rust,
138 bulk_dirs: Vec::new(),
140 include_target_in_component_name: false,
142 permit_symlinks: false,
146 pub(crate) fn set_overlay(&mut self, overlay: OverlayKind) {
147 self.overlay = overlay;
150 pub(crate) fn set_product_name(&mut self, name: &str) {
151 self.product_name = name.into();
154 pub(crate) fn include_target_in_component_name(&mut self, include: bool) {
155 self.include_target_in_component_name = include;
158 pub(crate) fn is_preview(&mut self, is: bool) {
159 self.is_preview = is;
162 pub(crate) fn permit_symlinks(&mut self, flag: bool) {
163 self.permit_symlinks = flag;
166 pub(crate) fn image_dir(&self) -> &Path {
167 t!(std::fs::create_dir_all(&self.image_dir));
171 pub(crate) fn add_file(&self, src: impl AsRef<Path>, destdir: impl AsRef<Path>, perms: u32) {
172 // create_dir_all fails to create `foo/bar/.`, so when the destination is "." this simply
173 // uses the base directory as the destination directory.
174 let destdir = if destdir.as_ref() == Path::new(".") {
175 self.image_dir.clone()
177 self.image_dir.join(destdir.as_ref())
180 t!(std::fs::create_dir_all(&destdir));
181 self.builder.install(src.as_ref(), &destdir, perms);
184 pub(crate) fn add_renamed_file(
186 src: impl AsRef<Path>,
187 destdir: impl AsRef<Path>,
190 let destdir = self.image_dir.join(destdir.as_ref());
191 t!(std::fs::create_dir_all(&destdir));
192 self.builder.copy(src.as_ref(), &destdir.join(new_name));
195 pub(crate) fn add_legal_and_readme_to(&self, destdir: impl AsRef<Path>) {
196 for file in self.overlay.legal_and_readme() {
197 self.add_file(self.builder.src.join(file), destdir.as_ref(), 0o644);
201 pub(crate) fn add_dir(&self, src: impl AsRef<Path>, dest: impl AsRef<Path>) {
202 let dest = self.image_dir.join(dest.as_ref());
204 t!(std::fs::create_dir_all(&dest));
205 self.builder.cp_r(src.as_ref(), &dest);
208 pub(crate) fn add_bulk_dir(&mut self, src: impl AsRef<Path>, dest: impl AsRef<Path>) {
209 self.bulk_dirs.push(dest.as_ref().to_path_buf());
210 self.add_dir(src, dest);
213 pub(crate) fn generate(self) -> GeneratedTarball {
214 let mut component_name = self.component.clone();
216 component_name.push_str("-preview");
218 if self.include_target_in_component_name {
219 component_name.push('-');
220 component_name.push_str(
224 .expect("include_target_in_component_name used in a targetless tarball"),
228 self.run(|this, cmd| {
231 .arg(&this.image_dir)
232 .arg(format!("--component-name={}", &component_name));
234 if let Some((dir, dirs)) = this.bulk_dirs.split_first() {
235 let mut arg = dir.as_os_str().to_os_string();
240 cmd.arg("--bulk-dirs").arg(&arg);
243 this.non_bare_args(cmd);
247 pub(crate) fn combine(self, tarballs: &[GeneratedTarball]) -> GeneratedTarball {
248 let mut input_tarballs = tarballs[0].path.as_os_str().to_os_string();
249 for tarball in &tarballs[1..] {
250 input_tarballs.push(",");
251 input_tarballs.push(&tarball.path);
254 self.run(|this, cmd| {
255 cmd.arg("combine").arg("--input-tarballs").arg(input_tarballs);
256 this.non_bare_args(cmd);
260 pub(crate) fn bare(self) -> GeneratedTarball {
261 // Bare tarballs should have the top level directory match the package
262 // name, not "image". We rename the image directory just before passing
263 // into rust-installer.
264 let dest = self.temp_dir.join(self.package_name());
265 t!(std::fs::rename(&self.image_dir, &dest));
267 self.run(|this, cmd| {
268 let distdir = crate::dist::distdir(this.builder);
269 t!(std::fs::create_dir_all(&distdir));
274 .arg(distdir.join(this.package_name()));
278 fn package_name(&self) -> String {
279 if let Some(target) = &self.target {
280 format!("{}-{}", self.pkgname, target)
286 fn non_bare_args(&self, cmd: &mut Command) {
287 cmd.arg("--rel-manifest-dir=rustlib")
288 .arg("--legacy-manifest-dirs=rustlib,cargo")
289 .arg(format!("--product-name={}", self.product_name))
290 .arg(format!("--success-message={} installed.", self.component))
291 .arg(format!("--package-name={}", self.package_name()))
292 .arg("--non-installed-overlay")
293 .arg(&self.overlay_dir)
295 .arg(crate::dist::distdir(self.builder));
298 fn run(self, build_cli: impl FnOnce(&Tarball<'a>, &mut Command)) -> GeneratedTarball {
299 t!(std::fs::create_dir_all(&self.overlay_dir));
300 self.builder.create(&self.overlay_dir.join("version"), &self.overlay.version(self.builder));
301 if let Some(info) = self.builder.rust_info.info() {
302 channel::write_commit_info_file(&self.overlay_dir, info);
304 for file in self.overlay.legal_and_readme() {
305 self.builder.install(&self.builder.src.join(file), &self.overlay_dir, 0o644);
308 let mut cmd = self.builder.tool_cmd(crate::tool::Tool::RustInstaller);
310 let package_name = self.package_name();
311 self.builder.info(&format!("Dist {}", package_name));
312 let _time = crate::util::timeit(self.builder);
314 build_cli(&self, &mut cmd);
315 cmd.arg("--work-dir").arg(&self.temp_dir);
316 if let Some(formats) = &self.builder.config.dist_compression_formats {
317 assert!(!formats.is_empty(), "dist.compression-formats can't be empty");
318 cmd.arg("--compression-formats").arg(formats.join(","));
320 self.builder.run(&mut cmd);
322 // Ensure there are no symbolic links in the tarball. In particular,
323 // rustup-toolchain-install-master and most versions of Windows can't handle symbolic links.
324 let decompressed_output = self.temp_dir.join(&package_name);
325 if !self.builder.config.dry_run && !self.permit_symlinks {
326 for entry in walkdir::WalkDir::new(&decompressed_output) {
327 let entry = t!(entry);
328 if entry.path_is_symlink() {
329 panic!("generated a symlink in a tarball: {}", entry.path().display());
334 // Use either the first compression format defined, or "gz" as the default.
338 .dist_compression_formats
340 .and_then(|formats| formats.get(0))
345 path: crate::dist::distdir(self.builder).join(format!("{}.tar.{}", package_name, ext)),
352 #[derive(Debug, Clone)]
353 pub struct GeneratedTarball {
355 decompressed_output: PathBuf,
359 impl GeneratedTarball {
360 pub(crate) fn tarball(&self) -> &Path {
364 pub(crate) fn decompressed_output(&self) -> &Path {
365 &self.decompressed_output
368 pub(crate) fn work_dir(&self) -> &Path {