feat: init mode alters profile scripts to update PATH (#35)

Fixes https://dfinity.atlassian.net/browse/SDK-1275

Author: Eric Swanson

CHANGELOG.md

@@ -9,6 +9,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased] - ReleaseDate
 
+- dfxvm-init now alters profile scripts to modify the PATH environment variable.
+
 ## [0.1.1] - 2023-12-04
 
 - Added `dfx` mode, which selects a dfx version and dispatches execution to it.

docs/cli-reference/dfxvm-init/dfxvm-init.md

@@ -17,6 +17,7 @@ dfxvm-init [--dfx-version <version>] [--proceed]
 |---------------------------| --- |
 | `--dfx-version <version>` | The version of dfx to install. Defaults to the latest dfx version |
 | `--proceed`               | Skip confirmation prompt |
+| `--no-modify-path`        | Do not alter profile scripts to modify the PATH environment variable |
 
 ## Examples
 

src/dfxvm_init/cli.rs

@@ -21,6 +21,10 @@ pub struct Cli {
     /// Automatically confirm options and proceed with install.
     #[clap(long)]
     proceed: bool,
+
+    /// Don't configure the PATH environment variable in profile scripts.
+    #[clap(long)]
+    no_modify_path: bool,
 }
 
 pub async fn main(args: &[OsString]) -> Result<ExitCode, dfxvm_init::Error> {
@@ -34,7 +38,9 @@ pub async fn main(args: &[OsString]) -> Result<ExitCode, dfxvm_init::Error> {
 
     let dfx_version = opts.dfx_version.map_or_else(|| Latest, Specific);
 
-    let options = PlanOptions::new().with_dfx_version(dfx_version);
+    let options = PlanOptions::new()
+        .with_dfx_version(dfx_version)
+        .with_modify_path(!opts.no_modify_path);
 
     initialize(options, confirmation).await?;
 

src/dfxvm_init/initialize.rs

@@ -4,9 +4,13 @@ use crate::dfxvm_init::{
     ui,
     ui::Confirmation,
 };
-use crate::error::{dfxvm_init, dfxvm_init::ExecutePlanError, fs::WriteFileError};
-use crate::fs::create_dir_all;
-use crate::installation::{env_file_contents, install_binaries};
+use crate::error::{
+    dfxvm_init,
+    dfxvm_init::{ExecutePlanError, UpdateProfileScriptsError},
+    fs::WriteFileError,
+};
+use crate::fs::{append_to_file, create_dir_all, read_to_string};
+use crate::installation::{env_file_contents, install_binaries, ProfileScript};
 use crate::locations::Locations;
 use std::path::Path;
 
@@ -53,10 +57,44 @@ pub async fn execute(plan: &Plan, locations: &Locations) -> Result<(), ExecutePl
         DfxVersion::Specific(version) => dfxvm::set_default(version, locations).await?,
     }
 
+    if plan.options.modify_path {
+        update_profile_scripts(&plan.profile_scripts)?;
+    }
+
     Ok(())
 }
 
 fn create_env_file(path: &Path) -> Result<(), WriteFileError> {
     info!("creating {}", path.display());
     crate::fs::write(path, env_file_contents())
 }
+
+fn update_profile_scripts(
+    profile_scripts: &Vec<ProfileScript>,
+) -> Result<(), UpdateProfileScriptsError> {
+    for profile_script in profile_scripts {
+        let path = &profile_script.path;
+        let rc = if path.exists() {
+            read_to_string(&profile_script.path)?
+        } else {
+            "".to_string()
+        };
+
+        let source_command = profile_script.source_string();
+        if rc.contains(&source_command) {
+            info!("already updates path: {}", path.display());
+            continue;
+        }
+
+        info!("updating {}", path.display());
+
+        let source_to_append = if rc.ends_with('\n') || rc.is_empty() {
+            source_command
+        } else {
+            format!("\n{}", source_command)
+        };
+
+        append_to_file(&profile_script.path, &source_to_append)?;
+    }
+    Ok(())
+}

src/dfxvm_init/plan.rs

@@ -1,4 +1,4 @@
-use crate::installation::get_env_path_user_facing;
+use crate::installation::{get_detected_profile_scripts, get_env_path_user_facing, ProfileScript};
 use crate::locations::Locations;
 use semver::Version;
 use std::path::PathBuf;
@@ -12,17 +12,29 @@ pub enum DfxVersion {
 #[derive(Clone)]
 pub struct PlanOptions {
     pub dfx_version: DfxVersion,
+    pub modify_path: bool,
 }
 
 impl PlanOptions {
     pub fn new() -> Self {
         Self {
             dfx_version: DfxVersion::Latest,
+            modify_path: true,
         }
     }
 
     pub fn with_dfx_version(self, dfx_version: DfxVersion) -> Self {
-        Self { dfx_version }
+        Self {
+            dfx_version,
+            ..self
+        }
+    }
+
+    pub fn with_modify_path(self, modify_path: bool) -> Self {
+        Self {
+            modify_path,
+            ..self
+        }
     }
 }
 
@@ -38,18 +50,22 @@ pub struct Plan {
     // to use with the "source" command, and also the path that we will use when
     // altering profile scripts.
     pub env_path_user_facing: String,
+
+    pub profile_scripts: Vec<ProfileScript>,
 }
 
 impl Plan {
     pub fn new(options: PlanOptions, locations: &Locations) -> Self {
         let bin_dir = locations.data_local_dir().join("bin");
         let env_path = locations.data_local_dir().join("env");
         let env_path_user_facing = get_env_path_user_facing().to_string();
+        let profile_scripts = get_detected_profile_scripts();
         Self {
             options,
             bin_dir,
             env_path,
             env_path_user_facing,
+            profile_scripts,
         }
     }
 

src/dfxvm_init/ui/customize.rs

@@ -1,6 +1,7 @@
 use crate::dfxvm_init::plan::{DfxVersion, Plan};
 use crate::error::dfxvm_init::InteractError;
 use crate::log::log_error;
+use dialoguer::Confirm;
 use semver::Version;
 
 pub fn customize(plan: Plan) -> Result<Plan, InteractError> {
@@ -13,6 +14,9 @@ pub fn customize(plan: Plan) -> Result<Plan, InteractError> {
     let dfx_version = select_dfx_version(&options.dfx_version)?;
     options = options.with_dfx_version(dfx_version);
 
+    let modify_path = select_modify_path(options.modify_path)?;
+    options = options.with_modify_path(modify_path);
+
     println!();
 
     Ok(plan.with_options(options))
@@ -44,3 +48,11 @@ fn select_dfx_version(install_dfx: &DfxVersion) -> Result<DfxVersion, InteractEr
     };
     Ok(dfx_version)
 }
+
+fn select_modify_path(current: bool) -> Result<bool, InteractError> {
+    let modify = Confirm::new()
+        .with_prompt("Modify PATH variable?")
+        .default(current)
+        .interact()?;
+    Ok(modify)
+}

src/dfxvm_init/ui/display.rs

@@ -1,6 +1,9 @@
 use crate::dfxvm_init::plan::{DfxVersion, Plan};
 use console::style;
 
+// Most of the text in this file is derived/copied/modified from:
+// https://github.com/rust-lang/rustup/blob/master/src/cli/self_update.rs
+
 pub fn introduction(plan: &Plan) {
     println!();
     println!("{}", style("Welcome to dfxvm!").bold());
@@ -14,6 +17,16 @@ pub fn introduction(plan: &Plan) {
     );
     println!();
     println!("   {}", plan.bin_dir.display());
+    if !plan.profile_scripts.is_empty() {
+        println!();
+        println!("This path will then be added to your PATH environment variable by");
+        println!("modifying the profile files located at:");
+        println!();
+
+        for script in &plan.profile_scripts {
+            println!("   {}", script.path.display());
+        }
+    }
     println!();
 }
 
@@ -23,20 +36,43 @@ pub fn options(plan: &Plan) {
         DfxVersion::Latest => "latest".to_string(),
         DfxVersion::Specific(version) => version.to_string(),
     };
+    let modify_path = if options.modify_path { "yes" } else { "no" };
 
     println!("Current installation options:");
     println!();
-    println!("   dfx version: {}", style(dfx_version).bold());
+    println!("            dfx version: {}", style(dfx_version).bold());
+    println!("   modify PATH variable: {}", style(modify_path).bold());
     println!();
 }
 
 pub fn success(plan: &Plan) {
     println!();
     println!("{}", style("dfxvm is installed now.").bold());
     println!();
-    println!("The installation process doesn't yet update profile scripts");
-    println!("to add the dfxvm bin directory to your $PATH.");
+    if plan.options.modify_path {
+        post_install_msg_unix_modify_path(plan);
+    } else {
+        post_install_msg_unix_no_modify_path(plan);
+    }
+}
+
+pub fn post_install_msg_unix_modify_path(plan: &Plan) {
+    println!("To get started you may need to restart your current shell.");
+    println!("This would reload your PATH environment variable to include");
+    println!("the dfxvm bin directory.");
     println!();
+    post_install_msg_unix_configure_shell(plan);
+}
+
+pub fn post_install_msg_unix_no_modify_path(plan: &Plan) {
+    println!("To get started you need the dfxvm bin directory in your PATH:");
+    println!("  {}", style(&plan.bin_dir.display()).bold());
+    println!("This has not been done automatically.");
+    println!();
+    post_install_msg_unix_configure_shell(plan);
+}
+
+pub fn post_install_msg_unix_configure_shell(plan: &Plan) {
     println!("To configure your shell, run:");
     println!(r#"  source "{}""#, plan.env_path_user_facing);
     println!();

src/error/dfxvm_init.rs

@@ -1,7 +1,7 @@
 use crate::error::{
     dfxvm,
     env::NoHomeDirectoryError,
-    fs::{CreateDirAllError, WriteFileError},
+    fs::{AppendToFileError, CreateDirAllError, ReadToStringError, WriteFileError},
     installation::InstallBinariesError,
 };
 use thiserror::Error;
@@ -32,6 +32,9 @@ pub enum ExecutePlanError {
     #[error(transparent)]
     Update(#[from] dfxvm::UpdateError),
 
+    #[error(transparent)]
+    UpdateProfileScripts(#[from] UpdateProfileScriptsError),
+
     #[error(transparent)]
     WriteFile(#[from] WriteFileError),
 }
@@ -42,3 +45,12 @@ pub struct InteractError {
     #[from]
     source: dialoguer::Error,
 }
+
+#[derive(Error, Debug)]
+pub enum UpdateProfileScriptsError {
+    #[error(transparent)]
+    AppendToFile(#[from] AppendToFileError),
+
+    #[error(transparent)]
+    ReadProfileScript(#[from] ReadToStringError),
+}

src/error/fs.rs

@@ -1,6 +1,18 @@
 use std::path::PathBuf;
 use thiserror::Error;
 
+#[derive(Error, Debug)]
+pub enum AppendToFileError {
+    #[error(transparent)]
+    Open(#[from] OpenFileError),
+
+    #[error(transparent)]
+    Write(#[from] WriteFileError),
+
+    #[error(transparent)]
+    Sync(#[from] SyncDataError),
+}
+
 #[derive(Error, Debug)]
 #[error("failed to canonicalize '{path}'")]
 pub struct CanonicalizePathError {
@@ -87,6 +99,13 @@ pub struct SetPermissionsError {
     pub source: std::io::Error,
 }
 
+#[derive(Error, Debug)]
+#[error("failed to sync data for {path}")]
+pub struct SyncDataError {
+    pub path: PathBuf,
+    pub source: std::io::Error,
+}
+
 #[derive(Error, Debug)]
 #[error("failed to write {path}")]
 pub struct WriteFileError {

src/fs.rs

@@ -1,10 +1,40 @@
 use crate::error::fs::{
-    CanonicalizePathError, CopyFileError, CreateDirAllError, CreateFileError, OpenFileError,
-    ReadFileError, ReadMetadataError, ReadToStringError, RemoveDirAllError, RemoveFileError,
-    RenameError, SetPermissionsError, WriteFileError,
+    AppendToFileError, CanonicalizePathError, CopyFileError, CreateDirAllError, CreateFileError,
+    OpenFileError, ReadFileError, ReadMetadataError, ReadToStringError, RemoveDirAllError,
+    RemoveFileError, RenameError, SetPermissionsError, SyncDataError, WriteFileError,
 };
+use std::io::Write;
 use std::path::{Path, PathBuf};
 
+// Derived from append_file() in https://github.com/rust-lang/rustup/blob/master/src/utils/raw.rs
+pub fn append_to_file(dest: &Path, line: &str) -> Result<(), AppendToFileError> {
+    let mut file = std::fs::OpenOptions::new()
+        .write(true)
+        .append(true)
+        .create(true)
+        .open(dest)
+        .map_err(|source| {
+            AppendToFileError::Open(OpenFileError {
+                path: dest.to_path_buf(),
+                source,
+            })
+        })?;
+
+    writeln!(file, "{line}").map_err(|source| {
+        AppendToFileError::Write(WriteFileError {
+            path: dest.to_path_buf(),
+            source,
+        })
+    })?;
+
+    file.sync_data().map_err(|source| {
+        AppendToFileError::Sync(SyncDataError {
+            path: dest.to_path_buf(),
+            source,
+        })
+    })
+}
+
 pub fn canonicalize(path: &Path) -> Result<PathBuf, CanonicalizePathError> {
     path.canonicalize().map_err(|source| CanonicalizePathError {
         path: path.to_path_buf(),