diff --git a/xtask/Cargo.toml b/xtask/Cargo.toml index aede498e0..95361f9b1 100644 --- a/xtask/Cargo.toml +++ b/xtask/Cargo.toml @@ -1,12 +1,13 @@ [package] name = "xtask" +description = "Cargo-based build system for Xous" version = "0.1.0" authors = ["Sean Cross "] edition = "2018" -# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html - [dependencies] +curl = "0.4" +atty = "0.2" filetime = "0.2" -#"ed25519-dalek" = "1" -#"pem" = "0.8" \ No newline at end of file +rustc_version = "0.4" +zip = "0.5" \ No newline at end of file diff --git a/xtask/src/main.rs b/xtask/src/main.rs index 1fb3fd3b0..0bbbf0cf3 100644 --- a/xtask/src/main.rs +++ b/xtask/src/main.rs @@ -9,6 +9,9 @@ type DynError = Box; const PROGRAM_TARGET: &str = "riscv32imac-unknown-xous-elf"; const KERNEL_TARGET: &str = "riscv32imac-unknown-xous-elf"; +const TOOLCHAIN_URL_PREFIX: &str = + "https://github.com/betrusted-io/rust/releases/latest/download/riscv32imac-unknown-xous_"; +const TOOLCHAIN_URL_SUFFIX: &str = ".zip"; enum MemorySpec { SvdFile(String), @@ -539,35 +542,215 @@ fn build_kernel(debug: bool) -> Result { Ok(path) } +/// Since we use the same TARGET for all calls to `build()`, +/// cache it inside an atomic boolean. If this is `true` then +/// it means we can assume the check passed already. static DONE_COMPILER_CHECK: std::sync::atomic::AtomicBool = std::sync::atomic::AtomicBool::new(false); + +/// Ensure we have a compatible compiler toolchain. We use a new Target, +/// and we want to give the user a friendly way of installing the latest +/// Rust toolchain. fn ensure_compiler(target: &Option<&str>) -> Result<(), String> { use std::process::Stdio; if DONE_COMPILER_CHECK.load(std::sync::atomic::Ordering::SeqCst) { - return Ok(()) + return Ok(()); } - let target = target.unwrap_or(PROGRAM_TARGET).to_owned(); - let have_toolchain = Command::new("rustc") - .stderr(Stdio::null()) - .stdout(Stdio::null()) - .args(&[ - "--target", - &target, - "--print", - "sysroot", - ]) - .spawn() - .unwrap() - .wait() - .unwrap() - .success(); - DONE_COMPILER_CHECK.store(have_toolchain, std::sync::atomic::Ordering::SeqCst); - if have_toolchain { - Ok(()) - } else { - Err(format!("Toolchain for {} not found", target)) + /// Return the sysroot for the given target. If the target does not exist, + /// return None. + fn get_sysroot(target: Option<&str>) -> Result, String> { + let mut args = vec!["--print", "sysroot"]; + if let Some(target) = target { + args.push("--target"); + args.push(target); + } + + let sysroot_cmd = Command::new("rustc") + .stderr(Stdio::null()) + .stdout(Stdio::piped()) + .args(&args) + .spawn() + .expect("could not run rustc"); + let sysroot_output = sysroot_cmd.wait_with_output().unwrap(); + let have_toolchain = sysroot_output.status.success(); + + let toolchain_path = String::from_utf8(sysroot_output.stdout) + .map_err(|_| "Unable to find Rust sysroot".to_owned())? + .trim() + .to_owned(); + + if have_toolchain { + Ok(Some(toolchain_path)) + } else { + Ok(None) + } } + + // If the sysroot exists, then we're good. + let target = target.unwrap_or(PROGRAM_TARGET); + if get_sysroot(Some(target))?.is_some() { + DONE_COMPILER_CHECK.store(true, std::sync::atomic::Ordering::SeqCst); + return Ok(()); + } + + // Since no sysroot exists, we must download a new one. + let toolchain_path = + get_sysroot(None)?.ok_or_else(|| "default toolchain not installed".to_owned())?; + // If the terminal is a tty, offer to download the latest toolchain. + if !atty::is(atty::Stream::Stdin) { + return Err(format!("Toolchain for {} not found", target)); + } + + // Version 1.54 was the last major version that was released. + let ver = rustc_version::version().unwrap(); + if ver.major == 1 && ver.minor < 54 { + return Err("Rust 1.54 or higher is required".into()); + } + + // Ask the user if they want to install the toolchain. + let mut buffer = String::new(); + let stdin = std::io::stdin(); + let mut stdout = std::io::stdout(); + println!(); + println!( + "Error: Toolchain for {} was not found on this system!", + target + ); + loop { + print!("Would you like this program to attempt to download and install it? [Y/n] "); + stdout.flush().unwrap(); + buffer.clear(); + stdin.read_line(&mut buffer).unwrap(); + + let trimmed = buffer.trim(); + + if trimmed == "n" || trimmed == "N" { + return Err(format!("Please install the {} toolchain", target)); + } + + if trimmed == "y" || trimmed == "Y" || trimmed.is_empty() { + break; + } + println!(); + } + + let toolchain_url = format!( + "{}{}.{}.{}{}", + TOOLCHAIN_URL_PREFIX, ver.major, ver.minor, ver.patch, TOOLCHAIN_URL_SUFFIX + ); + + println!( + "Attempting to install toolchain for {} into {}", + target, toolchain_path + ); + println!("Downloading from {}...", toolchain_url); + + print!("Download rogress: 0%"); + stdout.flush().unwrap(); + let mut zip_data = vec![]; + { + let mut easy = curl::easy::Easy::new(); + easy.url(&toolchain_url).unwrap(); + easy.follow_location(true).unwrap(); + easy.progress(true).unwrap(); + let mut transfer = easy.transfer(); + transfer + .progress_function( + |total_bytes, bytes_so_far, _total_uploaded, _uploaded_so_far| { + // If either number is infinite, don't print anything and just continue. + if total_bytes.is_infinite() || bytes_so_far.is_infinite() { + return true; + } + + // Display progress. + print!( + "\rDownload progress: {:3.02}% ", + bytes_so_far / total_bytes * 100.0 + ); + stdout.flush().unwrap(); + + // Return `true` to continue the transfer. + true + }, + ) + .unwrap(); + transfer + .write_function(|data| { + zip_data.extend_from_slice(data); + Ok(data.len()) + }) + .unwrap(); + transfer + .perform() + .map_err(|e| format!("Unable to download toolchain: {}", e))?; + println!(); + } + println!( + "Download successful. Total data size is {} bytes", + zip_data.len() + ); + + /// Extract the zipfile to the target directory, ensuring that all files + /// contained within are created. + fn extract_zip>( + archive_data: P, + extract_to: P2, + ) -> Result<(), String> { + let mut archive = zip::ZipArchive::new(archive_data) + .map_err(|e| format!("unable to extract zip: {}", e))?; + for i in 0..archive.len() { + let mut entry_in_archive = archive + .by_index(i) + .map_err(|e| format!("unable to locate file index {}: {}", i, e))?; + // println!( + // "Trying to extract file {}", + // entry_in_archive.mangled_name().display() + // ); + + let output_path = extract_to.as_ref().join(entry_in_archive.mangled_name()); + if entry_in_archive.is_dir() { + std::fs::create_dir_all(&output_path).map_err(|e| { + format!( + "unable to create directory {}: {}", + output_path.display(), + e + ) + })?; + } else { + // Create the parent directory if necessary + if let Some(parent) = output_path.parent() { + if !parent.exists() { + std::fs::create_dir_all(&parent).map_err(|e| { + format!( + "unable to create directory {}: {}", + output_path.display(), + e + ) + })?; + } + } + let mut outfile = std::fs::File::create(&output_path).map_err(|e| { + format!("unable to create file {}: {}", output_path.display(), e) + })?; + std::io::copy(&mut entry_in_archive, &mut outfile).map_err(|e| { + format!( + "unable to write extracted file {}: {}", + output_path.display(), + e + ) + })?; + } + } + Ok(()) + } + println!("Extracting toolchain to {}...", toolchain_path); + extract_zip(std::io::Cursor::new(zip_data), &toolchain_path)?; + + println!("Toolchain successfully installed"); + + DONE_COMPILER_CHECK.store(true, std::sync::atomic::Ordering::SeqCst); + Ok(()) } fn build(