From 27973e63b38af23a4db4ce63dc81fd575d8e2618 Mon Sep 17 00:00:00 2001 From: Simeon David Schaub Date: Mon, 27 Dec 2021 18:57:57 +0100 Subject: [PATCH] support nightly channels The way this works is that we mark which versions are nightly versions in the versions db during the build process and then special-case those when added as a channel or when updated. Right now, `juliaup update` will always download new nightly tarballs, which could potentially be wasteful if that's called again in quick succession, but I think for now that should be a reasonable solution. I have also gotten rid of a lot of code duplication in `build.rs`, which should make adding new platforms easier in the future. I hope I didn't miss anything there. Closes #96 --- build.rs | 787 +++++++++------------------------- src/command_update.rs | 17 +- src/config_file.rs | 2 + src/jsonstructs_versionsdb.rs | 6 +- src/operations.rs | 16 +- src/utils.rs | 13 + 6 files changed, 247 insertions(+), 594 deletions(-) diff --git a/build.rs b/build.rs index 9bf1f1da..7b61bced 100644 --- a/build.rs +++ b/build.rs @@ -23,6 +23,7 @@ fn produce_version_db() -> Result { let lts_version = Version::parse("1.6.5")?; let beta_version = Version::parse("1.7.1")?; let rc_version = Version::parse("1.7.1")?; + let nightly_version = Version::parse("1.8.0-latest")?; original_available_versions.push(Version::parse("0.7.0")?); original_available_versions.push(Version::parse("1.0.0")?); @@ -60,163 +61,18 @@ fn produce_version_db() -> Result { original_available_versions.push(Version::parse("1.7.0")?); original_available_versions.push(Version::parse("1.7.1")?); - let target_arch = std::env::var("CARGO_CFG_TARGET_ARCH")?; - let target_os = std::env::var("CARGO_CFG_TARGET_OS")?; - let mut db = JuliaupVersionDB { available_versions: HashMap::new(), available_channels: HashMap::new(), }; for v in &original_available_versions { - if target_os == "windows" && target_arch == "x86_64" { - db.available_versions.insert( - format!("{}+0~x64", v), - JuliaupVersionDBVersion {url_path: format!("bin/winnt/x64/{}.{}/julia-{}-win64.tar.gz", v.major, v.minor, v)} - ); - db.available_versions.insert( - format!("{}+0~x86", v), - JuliaupVersionDBVersion {url_path: format!("bin/winnt/x86/{}.{}/julia-{}-win32.tar.gz", v.major, v.minor, v)} - ); - } else if target_os == "windows" && target_arch == "x86" { - db.available_versions.insert( - format!("{}+0~x86", v), - JuliaupVersionDBVersion {url_path: format!("bin/winnt/x86/{}.{}/julia-{}-win32.tar.gz", v.major, v.minor, v)} - ); - } else if target_os == "linux" && target_arch == "x86_64" { - db.available_versions.insert( - format!("{}+0~x64", v), - JuliaupVersionDBVersion {url_path: format!("bin/linux/x64/{}.{}/julia-{}-linux-x86_64.tar.gz", v.major, v.minor, v)} - ); - db.available_versions.insert( - format!("{}+0~x86", v), - JuliaupVersionDBVersion {url_path: format!("bin/linux/x86/{}.{}/julia-{}-linux-i686.tar.gz", v.major, v.minor, v)} - ); - } else if target_os == "linux" && target_arch == "x86" { - db.available_versions.insert( - format!("{}+0~x86", v), - JuliaupVersionDBVersion {url_path: format!("bin/linux/x86/{}.{}/julia-{}-linux-i686.tar.gz", v.major, v.minor, v)} - ); - } else if target_os == "linux" && target_arch == "aarch64" { - db.available_versions.insert( - format!("{}+0~aarch64", v), - JuliaupVersionDBVersion {url_path: format!("bin/linux/aarch64/{}.{}/julia-{}-linux-aarch64.tar.gz", v.major, v.minor, v)} - ); - } else if target_os == "macos" && target_arch == "x86_64"{ - db.available_versions.insert( - format!("{}+0~x64", v), - JuliaupVersionDBVersion {url_path: format!("bin/mac/x64/{}.{}/julia-{}-mac64.tar.gz", v.major, v.minor, v)} - ); - } else if target_os == "macos" && target_arch == "aarch64"{ - db.available_versions.insert( - format!("{}+0~x64", v), - JuliaupVersionDBVersion {url_path: format!("bin/mac/x64/{}.{}/julia-{}-mac64.tar.gz", v.major, v.minor, v)} - ); + add_version(&mut db, v, false)?; + } - if v >= &Version::new(1,7, 0) { - db.available_versions.insert( - format!("{}+0~aarch64", v), - JuliaupVersionDBVersion {url_path: format!("bin/mac/aarch64/{}.{}/julia-{}-macaarch64.tar.gz", v.major, v.minor, v)} - ); - } + original_available_versions.push(nightly_version.clone()); - } else { - panic!("Building on this platform is currently not supported.") - } - - if target_arch == "x86_64" { - db.available_channels.insert( - format!("{}", v), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", v), - }, - ); - db.available_channels.insert( - format!("{}~x64", v), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", v), - }, - ); - db.available_channels.insert( - format!("{}~x86", v), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", v), - }, - ); - } else if target_arch == "x86" { - db.available_channels.insert( - format!("{}", v), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", v), - }, - ); - db.available_channels.insert( - format!("{}~x86", v), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", v), - }, - ); - } else if target_arch == "aarch64" { - if target_os == "windows" { - db.available_channels.insert( - format!("{}", v), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", v), - }, - ); - db.available_channels.insert( - format!("{}~x64", v), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", v), - }, - ); - db.available_channels.insert( - format!("{}~x86", v), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", v), - }, - ); - } else if target_os == "linux" { - db.available_channels.insert( - format!("{}", v), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", v), - }, - ); - db.available_channels.insert( - format!("{}~aarch64", v), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", v), - }, - ); - } else if target_os == "macos" { - db.available_channels.insert( - format!("{}", v), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", v), - }, - ); - db.available_channels.insert( - format!("{}~x64", v), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", v), - }, - ); - if v >= &Version::new(1,7, 0) { - db.available_channels.insert( - format!("{}~aarch64", v), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", v), - }, - ); - } - } else { - panic!("Building for this platform is currently not supported."); - } - } else { - panic!("Building on this platform is currently not supported.") - } - } + add_version(&mut db, &nightly_version, true)?; let minor_channels = &original_available_versions .iter() @@ -231,514 +87,279 @@ fn produce_version_db() -> Result { .max(); for ((major, minor), v) in minor_channels { - if target_arch == "x86_64" { - db.available_channels.insert( - format!("{}.{}", major, minor), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", v), - }, - ); - db.available_channels.insert( - format!("{}.{}~x64", major, minor), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", v), - }, - ); - db.available_channels.insert( - format!("{}.{}~x86", major, minor), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", v), - }, - ); - } else if target_arch == "x86" { - db.available_channels.insert( - format!("{}.{}", major, minor), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", v), - }, - ); - db.available_channels.insert( - format!("{}.{}~x86", major, minor), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", v), - }, - ); - } else if target_arch == "aarch64" { - if target_os == "windows" { - db.available_channels.insert( - format!("{}.{}", major, minor), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", v), - }, - ); - db.available_channels.insert( - format!("{}.{}~x64", major, minor), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", v), - }, - ); - db.available_channels.insert( - format!("{}.{}~x86", major, minor), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", v), - }, - ); - } else if target_os == "linux" { - db.available_channels.insert( - format!("{}.{}", major, minor), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", v), - }, + add_channels(&mut db, &format!("{}.{}", major, minor), v)?; + } + + for (major, v) in major_channels { + add_channels(&mut db, &major.to_string(), v)?; + } + + let release_version = &original_available_versions + .iter() + .filter(|&v| v.pre == semver::Prerelease::EMPTY) + .max() + .unwrap(); + + add_channels(&mut db, &"release", &release_version)?; + add_channels(&mut db, &"lts", <s_version)?; + add_channels(&mut db, &"beta", &beta_version)?; + add_channels(&mut db, &"rc", &rc_version)?; + add_channels(&mut db, &"nightly", &nightly_version)?; + + Ok(db) +} + +fn add_version( + db: &mut JuliaupVersionDB, + v: &Version, + nightly: bool, +) -> Result<()> { + let target_arch = std::env::var("CARGO_CFG_TARGET_ARCH")?; + let target_os = std::env::var("CARGO_CFG_TARGET_OS")?; + + let middle_part = if nightly { + "julia-latest".to_string() + } else { + format!("{}.{}/julia-{}", v.major, v.minor, v) + }; + + if target_os == "windows" && target_arch == "x86_64" { + db.available_versions.insert( + format!("{}+0~x64", v), + JuliaupVersionDBVersion { + url_path: format!("bin/winnt/x64/{}-win64.tar.gz", middle_part), + nightly: nightly, + } + ); + db.available_versions.insert( + format!("{}+0~x86", v), + JuliaupVersionDBVersion { + url_path: format!("bin/winnt/x86/{}-win32.tar.gz", middle_part), + nightly: nightly, + } + ); + } else if target_os == "windows" && target_arch == "x86" { + db.available_versions.insert( + format!("{}+0~x86", v), + JuliaupVersionDBVersion { + url_path: format!("bin/winnt/x86/{}-win32.tar.gz", middle_part), + nightly: nightly, + } + ); + } else if target_os == "linux" { + if nightly { + if target_arch == "x86_64" { + db.available_versions.insert( + format!("{}+0~x64", v), + JuliaupVersionDBVersion { + url_path: format!("bin/linux/x64/{}-linux64.tar.gz", middle_part), + nightly: nightly, + } ); - db.available_channels.insert( - format!("{}.{}~aarch64", major, minor), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", v), - }, + db.available_versions.insert( + format!("{}+0~x86", v), + JuliaupVersionDBVersion { + url_path: format!("bin/linux/x86/{}-linux32.tar.gz", middle_part), + nightly: nightly, + } ); - } else if target_os == "macos" { - db.available_channels.insert( - format!("{}.{}", major, minor), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", v), - }, + } else if target_arch == "x86" { + db.available_versions.insert( + format!("{}+0~x86", v), + JuliaupVersionDBVersion { + url_path: format!("bin/linux/x86/{}-linux-i686.tar.gz", middle_part), + nightly: nightly, + } ); - db.available_channels.insert( - format!("{}.{}~x64", major, minor), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", v), - }, + } else if target_arch == "aarch64" { + db.available_versions.insert( + format!("{}+0~aarch64", v), + JuliaupVersionDBVersion { + url_path: format!("bin/linux/aarch64/{}-linuxaarch64.tar.gz", middle_part), + nightly: nightly, + } ); - - if v >= &&Version::new(1,7, 0) { - db.available_channels.insert( - format!("{}.{}~aarch64", major, minor), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", v), - }, - ); - } } else { - panic!("Building for this platform is currently not supported.") + eprintln!("Nightly builds not available for this platform."); } } else { - panic!("Building on this platform is currently not supported.") - } - } - - for (major, v) in major_channels { - if target_arch == "x86_64" { - db.available_channels.insert( - format!("{}", major), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", v), - }, - ); - db.available_channels.insert( - format!("{}~x64", major), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", v), - }, - ); - db.available_channels.insert( - format!("{}~x86", major), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", v), - }, - ); - } else if target_arch == "x86" { - db.available_channels.insert( - format!("{}", major), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", v), - }, - ); - db.available_channels.insert( - format!("{}~x86", major), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", v), - }, - ); - } else if target_arch == "aarch64" { - if target_os == "windows" { - db.available_channels.insert( - format!("{}", major), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", v), - }, - ); - db.available_channels.insert( - format!("{}~x64", major), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", v), - }, - ); - db.available_channels.insert( - format!("{}~x86", major), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", v), - }, - ); - } else if target_os == "linux" { - db.available_channels.insert( - format!("{}", major), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", v), - }, + if target_arch == "x86_64" { + db.available_versions.insert( + format!("{}+0~x64", v), + JuliaupVersionDBVersion { + url_path: format!("bin/linux/x64/{}-linux-x86_64.tar.gz", middle_part), + nightly: nightly, + } ); - db.available_channels.insert( - format!("{}~aarch64", major), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", v), - }, + db.available_versions.insert( + format!("{}+0~x86", v), + JuliaupVersionDBVersion { + url_path: format!("bin/linux/x86/{}-linux-i686.tar.gz", middle_part), + nightly: nightly, + } ); - } else if target_os == "macos" { - db.available_channels.insert( - format!("{}", major), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", v), - }, + } else if target_arch == "x86" { + db.available_versions.insert( + format!("{}+0~x86", v), + JuliaupVersionDBVersion { + url_path: format!("bin/linux/x86/{}-linux-i686.tar.gz", middle_part), + nightly: nightly, + } ); - db.available_channels.insert( - format!("{}~x64", major), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", v), - }, + } else if target_arch == "aarch64" { + db.available_versions.insert( + format!("{}+0~aarch64", v), + JuliaupVersionDBVersion { + url_path: format!("bin/linux/aarch64/{}-linux-aarch64.tar.gz", middle_part), + nightly: nightly, + } ); + } else { + panic!("Building on this platform is currently not supported.") + } + } + } else if target_os == "macos" && target_arch == "x86_64"{ + db.available_versions.insert( + format!("{}+0~x64", v), + JuliaupVersionDBVersion { + url_path: format!("bin/mac/x64/{}-mac64.tar.gz", middle_part), + nightly: nightly, + } + ); + } else if target_os == "macos" && target_arch == "aarch64"{ + db.available_versions.insert( + format!("{}+0~x64", v), + JuliaupVersionDBVersion { + url_path: format!("bin/mac/x64/{}-mac64.tar.gz", middle_part), + nightly: nightly, + } + ); - if v >= &&Version::new(1,7, 0) { - db.available_channels.insert( - format!("{}~aarch64", major), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", v), - }, - ); + if v >= &Version::new(1,7, 0) { + if !nightly { + db.available_versions.insert( + format!("{}+0~aarch64", v), + JuliaupVersionDBVersion { + url_path: format!("bin/mac/aarch64/{}-macaarch64.tar.gz", middle_part), + nightly: nightly, } + ); } else { - panic!("Building on this platform is currently not supported.") + eprintln!("Nightly builds not available for this platform."); } - } else { - panic!("Building on this platform is currently not supported.") } + + } else { + panic!("Building on this platform is currently not supported.") } - let release_version = &original_available_versions - .iter() - .filter(|&v| v.pre == semver::Prerelease::EMPTY) - .max() - .unwrap(); + add_channels(db, &v.to_string(), v)?; - if target_arch == "x86_64" { - db.available_channels.insert( - "release".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", release_version), - }, - ); - db.available_channels.insert( - "release~x64".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", release_version), - }, - ); - db.available_channels.insert( - "release~x86".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", release_version), - }, - ); + Ok(()) +} +fn add_channels( + db: &mut JuliaupVersionDB, + name: &str, + v: &Version, +) -> Result<()> { + let target_arch = std::env::var("CARGO_CFG_TARGET_ARCH")?; + let target_os = std::env::var("CARGO_CFG_TARGET_OS")?; + + if target_arch == "x86_64" { db.available_channels.insert( - "lts".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", lts_version), - }, - ); - db.available_channels.insert( - "lts~x64".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", lts_version), - }, - ); - db.available_channels.insert( - "lts~x86".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", lts_version), - }, - ); - db.available_channels.insert( - "beta".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", beta_version), - }, - ); - db.available_channels.insert( - "beta~x64".to_string(), + format!("{}", name), JuliaupVersionDBChannel { - version: format!("{}+0~x64", beta_version), + version: format!("{}+0~x64", v), }, ); db.available_channels.insert( - "beta~x86".to_string(), + format!("{}~x64", name), JuliaupVersionDBChannel { - version: format!("{}+0~x86", beta_version), + version: format!("{}+0~x64", v), }, ); - db.available_channels.insert( - "rc".to_string(), + format!("{}~x86", name), JuliaupVersionDBChannel { - version: format!("{}+0~x64", rc_version), + version: format!("{}+0~x86", v), }, ); + } else if target_arch == "x86" { db.available_channels.insert( - "rc~x64".to_string(), + format!("{}", name), JuliaupVersionDBChannel { - version: format!("{}+0~x64", rc_version), + version: format!("{}+0~x86", v), }, ); db.available_channels.insert( - "rc~x86".to_string(), + format!("{}~x86", name), JuliaupVersionDBChannel { - version: format!("{}+0~x86", rc_version), + version: format!("{}+0~x86", v), }, ); } else if target_arch == "aarch64" { - if target_os == "linux" { - db.available_channels.insert( - "release".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", release_version), - }, - ); - db.available_channels.insert( - "release~aarch64".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", release_version), - }, - ); - - db.available_channels.insert( - "lts".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", lts_version), - }, - ); - db.available_channels.insert( - "lts~aarch64".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", lts_version), - }, - ); - - db.available_channels.insert( - "beta".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", beta_version), - }, - ); - db.available_channels.insert( - "beta~aarch64".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", beta_version), - }, - ); - - db.available_channels.insert( - "rc".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", rc_version), - }, - ); - db.available_channels.insert( - "rc~aarch64".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", rc_version), - }, - ); - } - else if target_os == "macos" { + if target_os == "windows" { db.available_channels.insert( - "release".to_string(), + format!("{}", name), JuliaupVersionDBChannel { - version: format!("{}+0~x64", release_version), - }, - ); - db.available_channels.insert( - "release~x64".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", release_version), - }, - ); - db.available_channels.insert( - "release~aarch64".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", release_version), - }, - ); - - - db.available_channels.insert( - "lts".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", lts_version), - }, - ); - db.available_channels.insert( - "lts~x64".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", lts_version), - }, - ); - - db.available_channels.insert( - "beta".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", beta_version), - }, - ); - db.available_channels.insert( - "beta~x64".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", beta_version), - }, - ); - db.available_channels.insert( - "beta~aarch64".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", beta_version), - }, - ); - - db.available_channels.insert( - "rc".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", rc_version), - }, - ); - db.available_channels.insert( - "rc~x64".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", rc_version), - }, - ); - db.available_channels.insert( - "rc~aarch64".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~aarch64", rc_version), - }, - ); - } - else { - db.available_channels.insert( - "release".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", release_version), - }, - ); - db.available_channels.insert( - "release~x64".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x64", release_version), + version: format!("{}+0~x86", v), }, ); - db.available_channels.insert( - "lts".to_string(), + format!("{}~x64", name), JuliaupVersionDBChannel { - version: format!("{}+0~x64", lts_version), + version: format!("{}+0~x64", v), }, ); db.available_channels.insert( - "lts~x64".to_string(), + format!("{}~x86", name), JuliaupVersionDBChannel { - version: format!("{}+0~x64", lts_version), + version: format!("{}+0~x86", v), }, ); - + } else if target_os == "linux" { db.available_channels.insert( - "beta".to_string(), + format!("{}", name), JuliaupVersionDBChannel { - version: format!("{}+0~x64", beta_version), + version: format!("{}+0~aarch64", v), }, ); db.available_channels.insert( - "beta~x64".to_string(), + format!("{}~aarch64", name), JuliaupVersionDBChannel { - version: format!("{}+0~x64", beta_version), + version: format!("{}+0~aarch64", v), }, ); - + } else if target_os == "macos" { db.available_channels.insert( - "rc".to_string(), + format!("{}", name), JuliaupVersionDBChannel { - version: format!("{}+0~x64", rc_version), + version: format!("{}+0~x64", v), }, ); db.available_channels.insert( - "rc~x64".to_string(), + format!("{}~x64", name), JuliaupVersionDBChannel { - version: format!("{}+0~x64", rc_version), + version: format!("{}+0~x64", v), }, ); + if v >= &Version::new(1,7, 0) { + db.available_channels.insert( + format!("{}~aarch64", name), + JuliaupVersionDBChannel { + version: format!("{}+0~aarch64", v), + }, + ); + } + } else { + panic!("Building for this platform is currently not supported."); } - } else if target_arch == "x86" { - db.available_channels.insert( - "release".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", release_version), - }, - ); - db.available_channels.insert( - "release~x86".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", release_version), - }, - ); - - db.available_channels.insert( - "lts".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", lts_version), - }, - ); - db.available_channels.insert( - "lts~x86".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", lts_version), - }, - ); - - db.available_channels.insert( - "beta".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", beta_version), - }, - ); - db.available_channels.insert( - "beta~x86".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", beta_version), - }, - ); - - db.available_channels.insert( - "rc".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", rc_version), - }, - ); - db.available_channels.insert( - "rc~x86".to_string(), - JuliaupVersionDBChannel { - version: format!("{}+0~x86", rc_version), - }, - ); } else { panic!("Building on this platform is currently not supported.") } - Ok(db) + Ok(()) } fn main() -> Result<()> { diff --git a/src/command_update.rs b/src/command_update.rs index 033e6490..bff86f30 100644 --- a/src/command_update.rs +++ b/src/command_update.rs @@ -12,16 +12,23 @@ fn update_channel(config_db: &mut JuliaupConfig, channel: &String, version_db: & match current_version { JuliaupConfigChannel::SystemChannel {version} => { - let should_version = version_db.available_channels.get(channel).ok_or(anyhow!("asdf"))?; + let should_version = &version_db.available_channels + .get(channel) + .ok_or(anyhow!("asdf"))? + .version; + let nightly = version_db.available_versions + .get(should_version) + .ok_or(anyhow!("asdf"))? + .nightly; - if &should_version.version != version { - install_version(&should_version.version, config_db, version_db) - .with_context(|| format!("Failed to install '{}' while updating channel '{}'.", should_version.version, channel))?; + if nightly || should_version != version { + install_version(should_version, config_db, version_db) + .with_context(|| format!("Failed to install '{}' while updating channel '{}'.", should_version, channel))?; config_db.installed_channels.insert( channel.clone(), JuliaupConfigChannel::SystemChannel { - version: should_version.version.clone(), + version: should_version.clone(), }, ); } diff --git a/src/config_file.rs b/src/config_file.rs index c780948f..9a6982c2 100644 --- a/src/config_file.rs +++ b/src/config_file.rs @@ -18,6 +18,8 @@ pub enum JuliaupConfigChannel { SystemChannel { #[serde(rename = "Version")] version: String, + //#[serde(rename = "Nightly")] + //nightly: String, }, LinkedChannel { #[serde(rename = "Command")] diff --git a/src/jsonstructs_versionsdb.rs b/src/jsonstructs_versionsdb.rs index a67dee6f..7d270ed6 100644 --- a/src/jsonstructs_versionsdb.rs +++ b/src/jsonstructs_versionsdb.rs @@ -4,13 +4,15 @@ use std::collections::HashMap; #[derive(Serialize, Deserialize)] pub struct JuliaupVersionDBVersion { #[serde(rename = "UrlPath")] - pub url_path: String + pub url_path: String, + #[serde(rename = "Nightly", default)] + pub nightly: bool, } #[derive(Serialize, Deserialize)] pub struct JuliaupVersionDBChannel { #[serde(rename = "Version")] - pub version: String + pub version: String, } #[derive(Serialize, Deserialize)] diff --git a/src/operations.rs b/src/operations.rs index 2939f4ed..61048e51 100644 --- a/src/operations.rs +++ b/src/operations.rs @@ -4,7 +4,7 @@ use crate::config_file::JuliaupConfigVersion; use crate::get_bundled_julia_full_version; use crate::jsonstructs_versionsdb::JuliaupVersionDB; use crate::utils::get_arch; -use crate::utils::get_juliaserver_base_url; +use crate::utils::{get_juliaserver_base_url, get_juliaserver_nightly_base_url}; use crate::utils::get_juliaup_home_path; use crate::utils::parse_versionstring; use anyhow::{anyhow, Context, Result}; @@ -81,8 +81,13 @@ pub fn install_version( config_data: &mut JuliaupConfig, version_db: &JuliaupVersionDB, ) -> Result<()> { + let nightly = version_db.available_versions + .get(fullversion) + .ok_or(anyhow!("Version {} does not exist", fullversion))? + .nightly; + // Return immediately if the version is already installed. - if config_data.installed_versions.contains_key(fullversion) { + if !nightly && config_data.installed_versions.contains_key(fullversion) { return Ok(()); } @@ -108,8 +113,11 @@ pub fn install_version( options.content_only = true; fs_extra::dir::copy(path_of_bundled_version, target_path, &options)?; } else { - let juliaupserver_base = get_juliaserver_base_url() - .with_context(|| "Failed to get Juliaup server base URL.")?; + let juliaupserver_base = if nightly { + get_juliaserver_nightly_base_url() + } else { + get_juliaserver_base_url() + }.with_context(|| "Failed to get Juliaup server base URL.")?; let download_url_path = &version_db .available_versions diff --git a/src/utils.rs b/src/utils.rs index 8cb5209e..0066f115 100644 --- a/src/utils.rs +++ b/src/utils.rs @@ -51,6 +51,19 @@ pub fn get_juliaserver_base_url() -> Result { Ok(parsed_url) } +pub fn get_juliaserver_nightly_base_url() -> Result { + let base_url = if let Ok(val) = std::env::var("JULIAUP_SERVER_NIGHTLY") { + val + } else { + "https://julialangnightlies-s3.julialang.org".to_string() + }; + + let parsed_url = Url::parse(&base_url) + .with_context(|| format!("Failed to parse the value of JULIAUP_SERVER_NIGHTLY '{}' as a uri.", base_url))?; + + Ok(parsed_url) +} + pub fn get_juliaupconfig_path() -> Result { let path = get_juliaup_home_path()?.join("juliaup.json");