From c88ca4c3b1f5d80ddbf652189fe8e9246fcc2b57 Mon Sep 17 00:00:00 2001 From: Arthur Beck Date: Thu, 12 Dec 2024 06:31:08 -0600 Subject: [PATCH] commit to work on my chromebook --- .gitignore | 5 +- Cargo.toml | 7 ++ rust-config.toml | 16 +-- src/copied.rs | 225 ++++++++++++++++++++++++++++++++++ src/lib.rs | 19 +-- src/main.rs | 133 +++++++++++++++++--- src/targets.rs | 275 ++++++++++++++++++++++++++++++++++++++++++ src/template/build.sh | 5 +- 8 files changed, 648 insertions(+), 37 deletions(-) create mode 100644 src/copied.rs create mode 100644 src/targets.rs diff --git a/.gitignore b/.gitignore index d01bd1a..18c116f 100644 --- a/.gitignore +++ b/.gitignore @@ -18,4 +18,7 @@ Cargo.lock # be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. -#.idea/ \ No newline at end of file +#.idea/ + +# normal data storage place when debugging +test/ \ No newline at end of file diff --git a/Cargo.toml b/Cargo.toml index 25603dd..84078dd 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,11 +4,18 @@ version = "0.1.0" edition = "2021" [dependencies] +anyhow = "1.0.94" clap = { version = "4.5.23", features = ["derive"]} clap_complete = "4.5.38" clap_mangen = "0.2.24" +dialoguer = "0.11.0" +filebuffer = "1.0.0" +hex = "0.4.3" rand = "0.8.5" regex = "1.11.1" +reqwest = {version = "0.12.9", features = ["blocking"]} rust-embed = "8.5.0" serde = {version="1.0.215", features = ["derive"]} +sha2 = "0.10.8" toml = "0.8.19" +url = "2.5.4" diff --git a/rust-config.toml b/rust-config.toml index 9787853..9528577 100644 --- a/rust-config.toml +++ b/rust-config.toml @@ -1,16 +1,16 @@ [x64_package_linux_rust_pkg_gen] toolchains = [ - {edition="2021", channel="1.83.0", profile="complete", components=["rustfmt", "rustc", "cargo"]} + { edition = "2021", channel = "nightly", profile = "complete", components = [ + "rustfmt", + "rustc", + "cargo", + ], crate_id = "2021-nightly-complete" }, ] [x64_package_linux_rust_pkg_gen.meta] offline = true -platforms = [ - "x86_64-unknown-linux-gnu" -] -targets = [ - "x86_64-unknown-linux-gnu" -] +platforms = ["x86_64-unknown-linux-gnu"] +targets = ["x86_64-unknown-linux-gnu"] [x64_package_linux_rust_pkg_gen.crates] -"*-nightly" = {"rust-embed"="2.0.90"} \ No newline at end of file +"2021-nightly-complete" = { "syn" = "2.0.90" } diff --git a/src/copied.rs b/src/copied.rs new file mode 100644 index 0000000..80fead4 --- /dev/null +++ b/src/copied.rs @@ -0,0 +1,225 @@ +// Copied from crate rustup-mirror(https://github.com/jiegec/rustup-mirror) +// Some modifications made due to deprecated/changed APIs +// (and differing purposes/necessities) + +use anyhow::{anyhow, Error}; +use filebuffer::FileBuffer; +use sha2::{Digest, Sha256}; +use std::collections::HashSet; +use std::fs::{copy, create_dir_all, File}; +use std::io::{Read, Write}; +use std::path::{Component, Path, PathBuf}; +use toml::Value; +use url::Url; + +pub const DEFAULT_UPSTREAM_URL: &str = "https://static.rust-lang.org/"; + +fn file_sha256(file_path: &Path) -> Option { + let file = Path::new(file_path); + if file.exists() { + let buffer = FileBuffer::open(&file).unwrap(); + Some(hex::encode(Sha256::new().chain_update(buffer).finalize())) + } else { + None + } +} + +fn download(upstream_url: &str, dir: &str, path: &str) -> Result { + let manifest = format!("{}{}", upstream_url, path); + let mut response = reqwest::blocking::get(&manifest)?; + let mirror = Path::new(dir); + let file_path = mirror.join(&path); + create_dir_all(file_path.parent().unwrap())?; + let mut dest = File::create(file_path)?; + + let length = match response.content_length() { + None => return Err(anyhow!("Not found")), + Some(l) => l, + }; + + let mut buffer = [0u8; 4096]; + let mut read = 0; + + while read < length { + let len = response.read(&mut buffer)?; + dest.write_all(&buffer[..len])?; + read += len as u64; + } + + Ok(mirror.join(path)) +} + +pub fn normalize_path(path: &Path) -> PathBuf { + let mut components = path.components().peekable(); + let mut ret = if let Some(c @ Component::Prefix(..)) = components.peek().cloned() { + components.next(); + PathBuf::from(c.as_os_str()) + } else { + PathBuf::new() + }; + + for component in components { + match component { + Component::Prefix(..) => unreachable!(), + Component::RootDir => { + ret.push(component.as_os_str()); + } + Component::CurDir => {} + Component::ParentDir => { + ret.pop(); + } + Component::Normal(c) => { + ret.push(c); + } + } + } + ret +} + +pub fn download_all( + channels: Vec<&str>, + upstream_url: &str, + orig_path: &str, + targets: Vec<&str>, + to_path: &str, + components: Vec<&str>, +) { + let mut all_targets = HashSet::new(); + + // All referenced files + let mut referenced = HashSet::new(); + + // Fetch rust components + for channel in channels.iter() { + let name = format!("dist/channel-rust-{}.toml", channel); + let file_path = download(upstream_url, orig_path, &name).unwrap(); + let sha256_name = format!("dist/channel-rust-{}.toml.sha256", channel); + let sha256_file_path = download(upstream_url, orig_path, &sha256_name).unwrap(); + + let mut file = File::open(file_path.clone()).unwrap(); + let mut data = String::new(); + file.read_to_string(&mut data).unwrap(); + + let mut sha256_file = File::open(sha256_file_path.clone()).unwrap(); + let mut sha256_data = String::new(); + sha256_file.read_to_string(&mut sha256_data).unwrap(); + assert_eq!( + file_sha256(file_path.as_path()).unwrap(), + &sha256_data[..64] + ); + + let mut value = data.parse::().unwrap(); + assert_eq!(value["manifest-version"].as_str(), Some("2")); + println!( + "Channel {} date {}", + channel, + value["date"].as_str().unwrap() + ); + + let pkgs = value["pkg"].as_table_mut().unwrap(); + let keys: Vec = pkgs.keys().cloned().collect(); + for pkg_name in keys { + if !components.contains(&pkg_name.as_str()) { + continue; + } + let pkg = pkgs.get_mut(&pkg_name).unwrap().as_table_mut().unwrap(); + let pkg_targets = pkg.get_mut("target").unwrap().as_table_mut().unwrap(); + for (target, pkg_target) in pkg_targets { + let pkg_target = pkg_target.as_table_mut().unwrap(); + + // if we don't want to download this target + // set available to false and do not download + // but we will keep this table in the toml, which is required for newer version of + // rustup + if !(targets.contains(&target.as_str()) || *target == "*") { + *pkg_target.get_mut("available").unwrap() = toml::Value::Boolean(false); + continue; + } + + if pkg_target["available"].as_bool().unwrap() { + all_targets.insert(target.clone()); + + let prefixes = ["", "xz_"]; + for prefix in prefixes.iter() { + let url = + Url::parse(pkg_target[&format!("{}url", prefix)].as_str().unwrap()) + .unwrap(); + let mirror = Path::new(to_path); + let file_name = url.path().replace("%20", " "); + let file = mirror.join(&file_name[1..]); + + referenced.insert(normalize_path(&file)); + + let hash_file = mirror.join(format!("{}.sha256", &file_name[1..])); + let hash_file_cont = + File::open(hash_file.clone()).ok().and_then(|mut f| { + let mut cont = String::new(); + f.read_to_string(&mut cont).ok().map(|_| cont) + }); + + let hash_file_missing = hash_file_cont.is_none(); + let mut hash_file_cont = + hash_file_cont.or_else(|| file_sha256(file.as_path())); + + let chksum_upstream = + pkg_target[&format!("{}hash", prefix)].as_str().unwrap(); + + let need_download = match hash_file_cont { + Some(ref chksum) => chksum_upstream != chksum, + None => true, + }; + + if need_download { + download(upstream_url, to_path, &file_name[1..]).unwrap(); + hash_file_cont = file_sha256(file.as_path()); + assert_eq!(Some(chksum_upstream), hash_file_cont.as_deref()); + } else { + println!("File {} already downloaded, skipping", file_name); + } + + if need_download || hash_file_missing { + File::create(hash_file) + .unwrap() + .write_all(hash_file_cont.unwrap().as_bytes()) + .unwrap(); + println!("Writing checksum for file {}", file_name); + } + + pkg_target.insert( + format!("{}url", prefix), + Value::String(format!("{}{}", upstream_url, file_name)), + ); + } + } + } + } + + let output = toml::to_string(&value).unwrap(); + let path = Path::new(to_path).join(&name); + create_dir_all(path.parent().unwrap()).unwrap(); + let mut file = File::create(path.clone()).unwrap(); + println!("Producing /{}", name); + file.write_all(output.as_bytes()).unwrap(); + + let sha256_new_file = file_sha256(&path).unwrap(); + let sha256_new_file_path = Path::new(to_path).join(&sha256_name); + let mut file = File::create(sha256_new_file_path.clone()).unwrap(); + println!("Producing /{}", sha256_name); + file.write_all(format!("{} channel-rust-{}.toml", sha256_new_file, channel).as_bytes()) + .unwrap(); + + let date = value["date"].as_str().unwrap(); + + let alt_name = format!("dist/{}/channel-rust-{}.toml", date, channel); + let alt_path = Path::new(to_path).join(&alt_name); + create_dir_all(alt_path.parent().unwrap()).unwrap(); + copy(path, alt_path).unwrap(); + println!("Producing /{}", alt_name); + + let alt_sha256_new_file_name = + format!("dist/{}/channel-rust-{}.toml.sha256", date, channel); + let alt_sha256_new_file_path = Path::new(to_path).join(&alt_sha256_new_file_name); + copy(sha256_new_file_path, alt_sha256_new_file_path).unwrap(); + println!("Producing /{}", alt_sha256_new_file_name); + } +} diff --git a/src/lib.rs b/src/lib.rs index 5225fd2..5fb7333 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,37 +1,40 @@ -use std::{collections::HashMap, fs, path::Path}; use serde::Deserialize; +use std::{collections::HashMap, fs, path::Path}; +pub mod copied; pub mod resources; +pub mod targets; mod tests; -#[derive(Deserialize, Debug)] +#[derive(Deserialize, Debug, Clone)] pub struct Toolchain { pub edition: String, pub channel: String, pub profile: String, - pub components: Vec + pub components: Vec, + pub crate_id: String, } -#[derive(Deserialize, Debug)] +#[derive(Deserialize, Debug, Clone)] pub struct Meta { pub offline: bool, pub platforms: Vec, - pub targets: Vec + pub targets: Vec, } pub type Crate = String; pub type Crates = HashMap>; -#[derive(Deserialize, Debug)] +#[derive(Deserialize, Debug, Clone)] pub struct RustConfigInner { pub toolchains: Vec, pub meta: Meta, - pub crates: Crates + pub crates: Crates, } pub type RustConfig = HashMap; pub fn parse_file(path: &Path) -> RustConfig { toml::from_str(&fs::read_to_string(path).unwrap()).unwrap() -} \ No newline at end of file +} diff --git a/src/main.rs b/src/main.rs index ab52210..bb2fe7d 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,41 +1,138 @@ -use std::{env, path::PathBuf}; +use clap::Parser; use rand::{Rng, SeedableRng}; -use rust_pkg_gen::parse_file; use rust_pkg_gen::resources::TemplateAssets; -use clap::Parser; +use std::path::PathBuf; fn gen_char() -> u8 { rand::rngs::StdRng::from_entropy().gen_range(65..90) } #[derive(Parser, Debug)] +#[command(version)] struct Cli { - #[arg(long="temp-dir", default_value="InVaLiD!")] - temp_dir: PathBuf, - #[arg(default_value="rust-config.toml")] + #[cfg(not(debug_assertions))] + #[arg(long = "temp-dir")] + temp_dir: Option, + + #[cfg(debug_assertions)] + #[arg(long = "temp-dir", default_value = "test")] + temp_dir: Option, + + #[arg( + short = 'y', + long = "yes", + default_value_t = false, + help = "Assume yes for all questions(excluding overwriting files)" + )] + yes: bool, + #[arg( + long = "overwrite", + default_value_t = false, + help = "The equivalent to --yes for overwriting files" + )] + overwrite: bool, + #[arg(default_value = "rust-config.toml", help = "")] path: PathBuf, } +fn generate_crates( + cfg: &rust_pkg_gen::RustConfigInner, + toolchain: &rust_pkg_gen::Toolchain, +) -> String { + let mut out: String = String::new(); + for (crte, version) in cfg.crates.get(&toolchain.crate_id).unwrap() { + out = format!("{}{} = \"{}\"\n", out, crte, version).to_string(); + } + out +} + fn main() { let args = Cli::parse(); let path = &PathBuf::from(args.path); - println!("{:#?}", parse_file(path)); - let chars: &[u8; 6] = &[gen_char(), gen_char(), gen_char(), gen_char(), gen_char(), gen_char()]; - let dir = if args.temp_dir != PathBuf::from("InVaLiD!") { - args.temp_dir + let chars: &[u8; 6] = &[ + gen_char(), + gen_char(), + gen_char(), + gen_char(), + gen_char(), + gen_char(), + ]; + let dir = if args.temp_dir.is_some() { + if args.temp_dir.clone().unwrap().exists() && !args.yes { + let confirmation = dialoguer::Confirm::new() + .with_prompt("Provided temporary directory already exists, overwrite?") + .default(false) + .interact() + .unwrap(); + if !confirmation { + println!("Aborting."); + std::process::exit(1) + } else { + println!("Overwriting."); + std::fs::remove_dir_all(args.temp_dir.clone().unwrap()).unwrap(); + } + } + args.temp_dir.unwrap() } else { std::env::temp_dir().join(PathBuf::from(String::from_utf8_lossy(chars).as_ref())) }; - let _ = std::fs::create_dir(dir.clone()); - for mut ele in TemplateAssets::iter() { - let file = TemplateAssets::get(&ele).unwrap(); - ele = ele.split_once("/").unwrap().1.as_ref(); - println!("{}", ele.as_ref()); - for ele in PathBuf::from(ele.as_ref()).ancestors() { - let _ = std::fs::create_dir(PathBuf::from().join(ele)); + + let data = rust_pkg_gen::parse_file(path); + + for (item, cfg) in data { + let dir = dir.join(item); + for toolchain in &cfg.toolchains { + for ele in TemplateAssets::iter() { + let file = TemplateAssets::get(&ele).unwrap(); + + let ele = std::borrow::Cow::Borrowed(ele.split_once("/").unwrap().1); + + let path = dir + .join(PathBuf::from("crates")) + .join(PathBuf::from(ele.as_ref())); + let prefix = path.parent().unwrap(); + std::fs::create_dir_all(prefix).unwrap(); + + std::fs::write( + path, + std::str::from_utf8(file.data.as_ref()) + .unwrap() + .replace("{?TOOLCHAIN.EDITION}", &toolchain.edition) + .replace("{?TOOLCHAIN.CHANNEL}", &toolchain.channel) + .replace("{?TOOLCHAIN.PROFILE}", &toolchain.profile) + .replace( + "{?META.TARGETS}", + &("\"".to_owned() + &cfg.meta.targets.join("\",\"") + "\""), + ) + .replace( + "{?TOOLCHAIN.COMPONENTS}", + &("\"".to_owned() + &toolchain.components.join("\",\"") + "\""), + ) + .replace("{?CRATES}", &generate_crates(&(cfg.clone()), &toolchain)), + ) + .unwrap(); + } + + std::process::Command::new("bash") + .arg( + dir.join(PathBuf::from("crates")) + .join(PathBuf::from("build.sh")), + ) + .spawn() + .unwrap() + .wait() + .unwrap(); + + rust_pkg_gen::copied::download_all( + vec!["nightly"], + rust_pkg_gen::copied::DEFAULT_UPSTREAM_URL, + dir.join("tmp").to_str().unwrap(), + vec!["x86_64-unknown-linux-gnu"], + dir.join("toolchain").to_str().unwrap(), + vec!["rustfmt", "rustc", "cargo"], + ); } - std::fs::write(dir.join(PathBuf::from(ele.as_ref())), file.data).unwrap(); } } diff --git a/src/targets.rs b/src/targets.rs new file mode 100644 index 0000000..b213a9e --- /dev/null +++ b/src/targets.rs @@ -0,0 +1,275 @@ +pub const RELEASE_CHANNELS: [&str; 3] = ["stable", "beta", "nightly"]; + +pub const TARGETS: [&str; 271] = [ + "aarch64-apple-darwin", + "aarch64-apple-ios", + "aarch64-apple-ios-macabi", + "aarch64-apple-ios-sim", + "aarch64-apple-tvos", + "aarch64-apple-tvos-sim", + "aarch64-apple-visionos", + "aarch64-apple-visionos-sim", + "aarch64-apple-watchos", + "aarch64-apple-watchos-sim", + "aarch64-kmc-solid_asp3", + "aarch64-linux-android", + "aarch64-nintendo-switch-freestanding", + "aarch64-pc-windows-gnullvm", + "aarch64-pc-windows-msvc", + "aarch64-unknown-freebsd", + "aarch64-unknown-fuchsia", + "aarch64-unknown-hermit", + "aarch64-unknown-illumos", + "aarch64-unknown-linux-gnu", + "aarch64-unknown-linux-gnu_ilp32", + "aarch64-unknown-linux-musl", + "aarch64-unknown-linux-ohos", + "aarch64-unknown-netbsd", + "aarch64-unknown-none", + "aarch64-unknown-none-softfloat", + "aarch64-unknown-nto-qnx700", + "aarch64-unknown-nto-qnx710", + "aarch64-unknown-openbsd", + "aarch64-unknown-redox", + "aarch64-unknown-teeos", + "aarch64-unknown-trusty", + "aarch64-unknown-uefi", + "aarch64-uwp-windows-msvc", + "aarch64-wrs-vxworks", + "aarch64_be-unknown-linux-gnu", + "aarch64_be-unknown-linux-gnu_ilp32", + "aarch64_be-unknown-netbsd", + "arm-linux-androideabi", + "arm-unknown-linux-gnueabi", + "arm-unknown-linux-gnueabihf", + "arm-unknown-linux-musleabi", + "arm-unknown-linux-musleabihf", + "arm64_32-apple-watchos", + "arm64e-apple-darwin", + "arm64e-apple-ios", + "arm64e-apple-tvos", + "arm64ec-pc-windows-msvc", + "armeb-unknown-linux-gnueabi", + "armebv7r-none-eabi", + "armebv7r-none-eabihf", + "armv4t-none-eabi", + "armv4t-unknown-linux-gnueabi", + "armv5te-none-eabi", + "armv5te-unknown-linux-gnueabi", + "armv5te-unknown-linux-musleabi", + "armv5te-unknown-linux-uclibceabi", + "armv6-unknown-freebsd", + "armv6-unknown-netbsd-eabihf", + "armv6k-nintendo-3ds", + "armv7-linux-androideabi", + "armv7-rtems-eabihf", + "armv7-sony-vita-newlibeabihf", + "armv7-unknown-freebsd", + "armv7-unknown-linux-gnueabi", + "armv7-unknown-linux-gnueabihf", + "armv7-unknown-linux-musleabi", + "armv7-unknown-linux-musleabihf", + "armv7-unknown-linux-ohos", + "armv7-unknown-linux-uclibceabi", + "armv7-unknown-linux-uclibceabihf", + "armv7-unknown-netbsd-eabihf", + "armv7-unknown-trusty", + "armv7-wrs-vxworks-eabihf", + "armv7a-kmc-solid_asp3-eabi", + "armv7a-kmc-solid_asp3-eabihf", + "armv7a-none-eabi", + "armv7a-none-eabihf", + "armv7k-apple-watchos", + "armv7r-none-eabi", + "armv7r-none-eabihf", + "armv7s-apple-ios", + "armv8r-none-eabihf", + "avr-unknown-gnu-atmega328", + "bpfeb-unknown-none", + "bpfel-unknown-none", + "csky-unknown-linux-gnuabiv2", + "csky-unknown-linux-gnuabiv2hf", + "hexagon-unknown-linux-musl", + "hexagon-unknown-none-elf", + "i386-apple-ios", + "i586-pc-nto-qnx700", + "i586-pc-windows-msvc", + "i586-unknown-linux-gnu", + "i586-unknown-linux-musl", + "i586-unknown-netbsd", + "i686-apple-darwin", + "i686-linux-android", + "i686-pc-windows-gnu", + "i686-pc-windows-gnullvm", + "i686-pc-windows-msvc", + "i686-unknown-freebsd", + "i686-unknown-haiku", + "i686-unknown-hurd-gnu", + "i686-unknown-linux-gnu", + "i686-unknown-linux-musl", + "i686-unknown-netbsd", + "i686-unknown-openbsd", + "i686-unknown-redox", + "i686-unknown-uefi", + "i686-uwp-windows-gnu", + "i686-uwp-windows-msvc", + "i686-win7-windows-msvc", + "i686-wrs-vxworks", + "loongarch64-unknown-linux-gnu", + "loongarch64-unknown-linux-musl", + "loongarch64-unknown-linux-ohos", + "loongarch64-unknown-none", + "loongarch64-unknown-none-softfloat", + "m68k-unknown-linux-gnu", + "mips-unknown-linux-gnu", + "mips-unknown-linux-musl", + "mips-unknown-linux-uclibc", + "mips64-openwrt-linux-musl", + "mips64-unknown-linux-gnuabi64", + "mips64-unknown-linux-muslabi64", + "mips64el-unknown-linux-gnuabi64", + "mips64el-unknown-linux-muslabi64", + "mipsel-sony-psp", + "mipsel-sony-psx", + "mipsel-unknown-linux-gnu", + "mipsel-unknown-linux-musl", + "mipsel-unknown-linux-uclibc", + "mipsel-unknown-netbsd", + "mipsel-unknown-none", + "mipsisa32r6-unknown-linux-gnu", + "mipsisa32r6el-unknown-linux-gnu", + "mipsisa64r6-unknown-linux-gnuabi64", + "mipsisa64r6el-unknown-linux-gnuabi64", + "msp430-none-elf", + "nvptx64-nvidia-cuda", + "powerpc-unknown-freebsd", + "powerpc-unknown-linux-gnu", + "powerpc-unknown-linux-gnuspe", + "powerpc-unknown-linux-musl", + "powerpc-unknown-linux-muslspe", + "powerpc-unknown-netbsd", + "powerpc-unknown-openbsd", + "powerpc-wrs-vxworks", + "powerpc-wrs-vxworks-spe", + "powerpc64-ibm-aix", + "powerpc64-unknown-freebsd", + "powerpc64-unknown-linux-gnu", + "powerpc64-unknown-linux-musl", + "powerpc64-unknown-openbsd", + "powerpc64-wrs-vxworks", + "powerpc64le-unknown-freebsd", + "powerpc64le-unknown-linux-gnu", + "powerpc64le-unknown-linux-musl", + "riscv32-wrs-vxworks", + "riscv32e-unknown-none-elf", + "riscv32em-unknown-none-elf", + "riscv32emc-unknown-none-elf", + "riscv32gc-unknown-linux-gnu", + "riscv32gc-unknown-linux-musl", + "riscv32i-unknown-none-elf", + "riscv32im-risc0-zkvm-elf", + "riscv32im-unknown-none-elf", + "riscv32ima-unknown-none-elf", + "riscv32imac-esp-espidf", + "riscv32imac-unknown-none-elf", + "riscv32imac-unknown-nuttx-elf", + "riscv32imac-unknown-xous-elf", + "riscv32imafc-esp-espidf", + "riscv32imafc-unknown-none-elf", + "riscv32imafc-unknown-nuttx-elf", + "riscv32imc-esp-espidf", + "riscv32imc-unknown-none-elf", + "riscv32imc-unknown-nuttx-elf", + "riscv64-linux-android", + "riscv64-wrs-vxworks", + "riscv64gc-unknown-freebsd", + "riscv64gc-unknown-fuchsia", + "riscv64gc-unknown-hermit", + "riscv64gc-unknown-linux-gnu", + "riscv64gc-unknown-linux-musl", + "riscv64gc-unknown-netbsd", + "riscv64gc-unknown-none-elf", + "riscv64gc-unknown-nuttx-elf", + "riscv64gc-unknown-openbsd", + "riscv64imac-unknown-none-elf", + "riscv64imac-unknown-nuttx-elf", + "s390x-unknown-linux-gnu", + "s390x-unknown-linux-musl", + "sparc-unknown-linux-gnu", + "sparc-unknown-none-elf", + "sparc64-unknown-linux-gnu", + "sparc64-unknown-netbsd", + "sparc64-unknown-openbsd", + "sparcv9-sun-solaris", + "thumbv4t-none-eabi", + "thumbv5te-none-eabi", + "thumbv6m-none-eabi", + "thumbv6m-nuttx-eabi", + "thumbv7a-pc-windows-msvc", + "thumbv7a-uwp-windows-msvc", + "thumbv7em-none-eabi", + "thumbv7em-none-eabihf", + "thumbv7em-nuttx-eabi", + "thumbv7em-nuttx-eabihf", + "thumbv7m-none-eabi", + "thumbv7m-nuttx-eabi", + "thumbv7neon-linux-androideabi", + "thumbv7neon-unknown-linux-gnueabihf", + "thumbv7neon-unknown-linux-musleabihf", + "thumbv8m.base-none-eabi", + "thumbv8m.base-nuttx-eabi", + "thumbv8m.main-none-eabi", + "thumbv8m.main-none-eabihf", + "thumbv8m.main-nuttx-eabi", + "thumbv8m.main-nuttx-eabihf", + "wasm32-unknown-emscripten", + "wasm32-unknown-unknown", + "wasm32-wasip1", + "wasm32-wasip1-threads", + "wasm32-wasip2", + "wasm32v1-none", + "wasm64-unknown-unknown", + "x86_64-apple-darwin", + "x86_64-apple-ios", + "x86_64-apple-ios-macabi", + "x86_64-apple-tvos", + "x86_64-apple-watchos-sim", + "x86_64-fortanix-unknown-sgx", + "x86_64-linux-android", + "x86_64-pc-nto-qnx710", + "x86_64-pc-solaris", + "x86_64-pc-windows-gnu", + "x86_64-pc-windows-gnullvm", + "x86_64-pc-windows-msvc", + "x86_64-unikraft-linux-musl", + "x86_64-unknown-dragonfly", + "x86_64-unknown-freebsd", + "x86_64-unknown-fuchsia", + "x86_64-unknown-haiku", + "x86_64-unknown-hermit", + "x86_64-unknown-hurd-gnu", + "x86_64-unknown-illumos", + "x86_64-unknown-l4re-uclibc", + "x86_64-unknown-linux-gnu", + "x86_64-unknown-linux-gnux32", + "x86_64-unknown-linux-musl", + "x86_64-unknown-linux-none", + "x86_64-unknown-linux-ohos", + "x86_64-unknown-netbsd", + "x86_64-unknown-none", + "x86_64-unknown-openbsd", + "x86_64-unknown-redox", + "x86_64-unknown-trusty", + "x86_64-unknown-uefi", + "x86_64-uwp-windows-gnu", + "x86_64-uwp-windows-msvc", + "x86_64-win7-windows-msvc", + "x86_64-wrs-vxworks", + "x86_64h-apple-darwin", + "xtensa-esp32-espidf", + "xtensa-esp32-none-elf", + "xtensa-esp32s2-espidf", + "xtensa-esp32s2-none-elf", + "xtensa-esp32s3-espidf", + "xtensa-esp32s3-none-elf", +]; diff --git a/src/template/build.sh b/src/template/build.sh index b6382dd..06f09a0 100644 --- a/src/template/build.sh +++ b/src/template/build.sh @@ -1,3 +1,4 @@ -#!/bin/bash +#!/usr/bin/env bash +cd "$(dirname "$0")" cargo generate-lockfile --verbose -cargo vendor --verbose --locked crates \ No newline at end of file +cargo vendor --verbose --locked ./crates \ No newline at end of file