Merge pull request #809 from JuliaLang/da/nightly

Nightly

Cargo.toml

@@ -61,7 +61,7 @@ path-absolutize = "3.1.0"
 human-sort = "0.2.2"
 
 [target.'cfg(windows)'.dependencies]
-windows = { version = "0.52.0", features = ["Win32_Foundation", "Win32_UI_Shell", "Win32_System_Console", "Services_Store", "Foundation", "Foundation_Collections", "Web_Http", "Storage_Streams",] }
+windows = { version = "0.52.0", features = ["Win32_Foundation", "Win32_UI_Shell", "Win32_System_Console", "Services_Store", "Foundation", "Foundation_Collections", "Web_Http", "Web_Http_Headers", "Storage_Streams",] }
 
 [target.'cfg(target_os = "macos")'.dependencies]
 reqwest = { version = "0.11.18", default-features = false, features = ["blocking", "native-tls", "socks"] }

README.md

@@ -117,6 +117,7 @@ The available system provided channels are:
 - `lts`: always points to the latest long term supported version.
 - `beta`: always points to the latest beta version if one exists. If a newer release candidate exists, it will point to that, and if there is neither a beta or rc candidate available it will point to the same version as the `release` channel.
 - `rc`: same as `beta`, but only starts with release candidate versions.
+- `nightly`: always points to the latest build from the `master` branch in the Julia repository.
 - specific versions, e.g. `1.5.4`.
 - minor version channels, e.g. `1.5`.
 - major version channels, e.g. `1`.

src/bin/julialauncher.rs

@@ -208,7 +208,7 @@ fn get_julia_path_from_channel(
 
  check_channel_uptodate(channel, version, versions_db).with_context(|| {
  format!(
- "The Julia launcher failed while checking whether the channe {} is up-to-date.",
+ "The Julia launcher failed while checking whether the channel {} is up-to-date.",
  channel
  )
  })?;
@@ -227,6 +227,39 @@ fn get_julia_path_from_channel(
  })?;
  return Ok((absolute_path.into_path_buf(), Vec::new()));
  }
+ JuliaupConfigChannel::DirectDownloadChannel {
+ path,
+ url: _,
+ local_etag,
+ server_etag,
+ version: _,
+ } => {
+ if local_etag != server_etag {
+ eprintln!(
+ "A new version of Julia for the `{}` channel is available. Run:",
+ channel
+ );
+ eprintln!();
+ eprintln!(" juliaup update");
+ eprintln!();
+ eprintln!("to install the latest Julia for the `{}` channel.", channel);
+ }
+
+ let absolute_path = juliaupconfig_path
+ .parent()
+ .unwrap()
+ .join(path)
+ .join("bin")
+ .join(format!("julia{}", std::env::consts::EXE_SUFFIX))
+ .normalize()
+ .with_context(|| {
+ format!(
+ "Failed to normalize path for Julia binary, starting from `{}`.",
+ juliaupconfig_path.display()
+ )
+ })?;
+ return Ok((absolute_path.into_path_buf(), Vec::new()));
+ }
  }
 }
 

src/command_add.rs

@@ -2,11 +2,15 @@ use crate::config_file::{load_mut_config_db, save_config_db, JuliaupConfigChanne
 use crate::global_paths::GlobalPaths;
 #[cfg(not(windows))]
 use crate::operations::create_symlink;
-use crate::operations::{install_version, update_version_db};
+use crate::operations::{identify_nightly, install_nightly, install_version, update_version_db};
 use crate::versions_file::load_versions_db;
 use anyhow::{anyhow, Context, Result};
 
 pub fn run_command_add(channel: &str, paths: &GlobalPaths) -> Result<()> {
+ if channel == "nightly" || channel.starts_with("nightly~") {
+ return add_nightly(channel, paths);
+ }
+
  update_version_db(paths).with_context(|| "Failed to update versions db.")?;
  let version_db =
  load_versions_db(paths).with_context(|| "`add` command failed to load versions db.")?;
@@ -66,3 +70,37 @@ pub fn run_command_add(channel: &str, paths: &GlobalPaths) -> Result<()> {
 
  Ok(())
 }
+
+fn add_nightly(channel: &str, paths: &GlobalPaths) -> Result<()> {
+ let mut config_file = load_mut_config_db(paths)
+ .with_context(|| "`add` command failed to load configuration data.")?;
+
+ if config_file.data.installed_channels.contains_key(channel) {
+ eprintln!("'{}' is already installed.", &channel);
+ return Ok(());
+ }
+
+ let name = identify_nightly(&channel.to_string())?;
+ let config_channel = install_nightly(channel, &name, paths)?;
+
+ config_file
+ .data
+ .installed_channels
+ .insert(channel.to_string(), config_channel.clone());
+
+ if config_file.data.default.is_none() {
+ config_file.data.default = Some(channel.to_string());
+ }
+
+ save_config_db(&mut config_file).with_context(|| {
+ format!(
+ "Failed to save configuration file from `add` command after '{channel}' was installed.",
+ )
+ })?;
+
+ #[cfg(not(windows))]
+ if config_file.data.settings.create_channel_symlinks {
+ create_symlink(&config_channel, &format!("julia-{}", channel), paths)?;
+ }
+ Ok(())
+}

src/command_api.rs

@@ -109,6 +109,23 @@ pub fn run_command_api(command: &str, paths: &GlobalPaths) -> Result<()> {
  Err(_) => continue,
  }
  }
+ JuliaupConfigChannel::DirectDownloadChannel { path, url: _, local_etag: _, server_etag: _, version } => {
+ JuliaupChannelInfo {
+ name: key.clone(),
+ file: paths.juliauphome
+ .join(path)
+ .join("bin")
+ .join(format!("julia{}", std::env::consts::EXE_SUFFIX))
+ .normalize()
+ .with_context(|| "Normalizing the path for an entry from the config file failed while running the getconfig1 API command.")?
+ .into_path_buf()
+ .to_string_lossy()
+ .to_string(),
+ args: Vec::new(),
+ version: version.clone(),
+ arch: "".to_string(),
+ }
+ }
  };
 
  match config_file.data.default {

src/command_list.rs

@@ -1,3 +1,4 @@
+use crate::operations::{compatible_nightly_archs, identify_nightly};
 use crate::{global_paths::GlobalPaths, versions_file::load_versions_db};
 use anyhow::{Context, Result};
 use cli_table::{
@@ -19,6 +20,24 @@ pub fn run_command_list(paths: &GlobalPaths) -> Result<()> {
  let versiondb_data =
  load_versions_db(paths).with_context(|| "`list` command failed to load versions db.")?;
 
+ let nightly_channels: Vec<String> = std::iter::once("nightly".to_string())
+ .chain(
+ compatible_nightly_archs()?
+ .into_iter()
+ .map(|arch| format!("nightly~{}", arch)),
+ )
+ .collect();
+ let nightly_rows: Vec<ChannelRow> = nightly_channels
+ .into_iter()
+ .map(|channel| {
+ let nightly_name = identify_nightly(&channel).expect("Failed to identify nightly");
+ ChannelRow {
+ name: channel,
+ version: nightly_name,
+ }
+ })
+ .collect();
+
  let rows_in_table: Vec<_> = versiondb_data
  .available_channels
  .iter()
@@ -29,6 +48,7 @@ pub fn run_command_list(paths: &GlobalPaths) -> Result<()> {
  }
  })
  .sorted_by(|a, b| compare(&a.name, &b.name))
+ .chain(nightly_rows)
  .collect();
 
  print_stdout(

src/command_remove.rs

@@ -1,7 +1,7 @@
 #[cfg(not(windows))]
 use crate::operations::remove_symlink;
 use crate::{
- config_file::{load_mut_config_db, save_config_db},
+ config_file::{load_mut_config_db, save_config_db, JuliaupConfigChannel},
  global_paths::GlobalPaths,
  operations::garbage_collect_versions,
 };
@@ -39,6 +39,25 @@ pub fn run_command_remove(channel: &str, paths: &GlobalPaths) -> Result<()> {
  );
  }
 
+ let x = config_file.data.installed_channels.get(channel).unwrap();
+
+ if let JuliaupConfigChannel::DirectDownloadChannel {
+ path,
+ url: _,
+ local_etag: _,
+ server_etag: _,
+ version: _,
+ } = x
+ {
+ let path_to_delete = paths.juliauphome.join(&path);
+
+ let display = path_to_delete.display();
+
+ if std::fs::remove_dir_all(&path_to_delete).is_err() {
+ eprintln!("WARNING: Failed to delete {}. You can try to delete at a later point by running `juliaup gc`.", display)
+ }
+ };
+
  config_file.data.installed_channels.remove(channel);
 
  #[cfg(not(windows))]

src/command_status.rs

@@ -52,6 +52,15 @@ pub fn run_command_status(paths: &GlobalPaths) -> Result<()> {
  name: i.0.to_string(),
  version: match i.1 {
  JuliaupConfigChannel::SystemChannel { version } => version.clone(),
+ JuliaupConfigChannel::DirectDownloadChannel {
+ path: _,
+ url: _,
+ local_etag: _,
+ server_etag: _,
+ version,
+ } => {
+ format!("Development version {}", version)
+ }
  JuliaupConfigChannel::LinkedChannel { command, args } => {
  let mut combined_command = String::new();
 
@@ -95,6 +104,19 @@ pub fn run_command_status(paths: &GlobalPaths) -> Result<()> {
  command: _,
  args: _,
  } => "".to_string(),
+ JuliaupConfigChannel::DirectDownloadChannel {
+ path: _,
+ url: _,
+ local_etag,
+ server_etag,
+ version: _,
+ } => {
+ if local_etag != server_etag {
+ "Update available".to_string()
+ } else {
+ "".to_string()
+ }
+ }
  },
  }
  })

src/command_update.rs

@@ -4,10 +4,11 @@ use crate::global_paths::GlobalPaths;
 use crate::jsonstructs_versionsdb::JuliaupVersionDB;
 #[cfg(not(windows))]
 use crate::operations::create_symlink;
-use crate::operations::garbage_collect_versions;
+use crate::operations::{garbage_collect_versions, install_from_url};
 use crate::operations::{install_version, update_version_db};
 use crate::versions_file::load_versions_db;
 use anyhow::{anyhow, bail, Context, Result};
+use std::path::PathBuf;
 
 fn update_channel(
  config_db: &mut JuliaupConfig,
@@ -17,7 +18,7 @@ fn update_channel(
  paths: &GlobalPaths,
 ) -> Result<()> {
  let current_version =
- config_db.installed_channels.get(channel).ok_or_else(|| anyhow!("Trying to get the installed version for a channel that does not exist in the config database."))?;
+ &config_db.installed_channels.get(channel).ok_or_else(|| anyhow!("Trying to get the installed version for a channel that does not exist in the config database."))?.clone();
 
  match current_version {
  JuliaupConfigChannel::SystemChannel { version } => {
@@ -71,6 +72,40 @@ fn update_channel(
  );
  }
  }
+ JuliaupConfigChannel::DirectDownloadChannel {
+ path,
+ url,
+ local_etag,
+ server_etag,
+ version,
+ } => {
+ // We only do this so that we use `version` on both Windows and Linux to prevent a compiler warning/error
+ assert!(!version.is_empty());
+
+ if local_etag != server_etag {
+ let channel_data =
+ install_from_url(&url::Url::parse(url)?, &PathBuf::from(path), paths)?;
+
+ config_db
+ .installed_channels
+ .insert(channel.clone(), channel_data);
+
+ #[cfg(not(windows))]
+ if config_db.settings.create_channel_symlinks {
+ create_symlink(
+ &JuliaupConfigChannel::DirectDownloadChannel {
+ path: path.clone(),
+ url: url.clone(),
+ local_etag: local_etag.clone(),
+ server_etag: server_etag.clone(),
+ version: version.clone(),
+ },
+ &channel,
+ paths,
+ )?;
+ }
+ }
+ }
  }
 
  Ok(())

src/config_file.rs

@@ -29,6 +29,18 @@ pub struct JuliaupConfigVersion {
 #[derive(Serialize, Deserialize, Clone)]
 #[serde(untagged)]
 pub enum JuliaupConfigChannel {
+ DirectDownloadChannel {
+ #[serde(rename = "Path")]
+ path: String,
+ #[serde(rename = "Url")]
+ url: String,
+ #[serde(rename = "LocalETag")]
+ local_etag: String,
+ #[serde(rename = "ServerETag")]
+ server_etag: String,
+ #[serde(rename = "Version")]
+ version: String,
+ },
  SystemChannel {
  #[serde(rename = "Version")]
  version: String,