change mode detection, check by detecting installation record instead

Author: J-ZhengLi

README.md

@@ -64,12 +64,11 @@ After env setup, it will guide you through installing Rust `toolkit`.
 - Debug `installer` mode:
   - Commandline interface
   ```bash
-  cargo run
+  cargo dev run --cli --installer
   ```
   - Graphical interface
   ```bash
-  cd rim_gui
-  pnpm run tauri dev
+  pnpm dev run --installer
   ```
 - Debug `manager` mode:
   > Running `manager` is not as straight forward as running in `Installer` mode.
@@ -78,7 +77,7 @@ After env setup, it will guide you through installing Rust `toolkit`.
   so you can test `manager`'s functionalities easier.
 
   ```bash
-  cargo dev run-manager
+  cargo dev run --manager
   ```
 
 ### Release
@@ -140,12 +139,8 @@ Options:
 
 ### Manager mode (CLI)
 
-> Manager mode can be activated by:
->
-> 1. Renaming the binary to one that contains `manager`, such as `manager-cli`
-> 2. Having a `MODE` environment variable set to `manager` before running the program, such as running `export MODE='manager'` in Unix systems.
->
-> NOTE: **Manager will be automatically deployed after installation, and must be run inside of the installation directory to avoid crash**
+> Manager mode will run after an installation record was detected, and it can also be overridden by
+> having a `MODE` environment variable set to `manager` before running the program, such as running `export MODE='manager'` in Unix systems.
 
 ```console
 Usage: MODE='manager' rim-cli.exe [OPTIONS] [COMMAND]

rim_dev/README.md

@@ -13,8 +13,8 @@ Options:
     -h, -help       Print this help message
 
 Commands:
-    dist, d         Generate release binaries
-    run-manager     Run in manager mode
+    d, dist         Generate release binaries
+    r, run          Build and run RIM for testing purpose
     vendor          Download packages for offline package build
     mock-rustup-server
                     Generate a mocked rustup dist server
@@ -23,19 +23,19 @@ Commands:
 ### Debug manager (GUI)
 
 ```bash
-cargo dev run-manager
+cargo dev run --manager
 ```
 
 ### Debug manager (CLI)
 
 ```bash
-cargo dev run-manager --cli
+cargo dev run --manager --cli
 ```
 
 check for more manager-mode help
 
 ```bash
-cargo dev run-manager --help
+cargo dev run --manager --help
 ```
 
 ### Generate release binaries

rim_dev/src/main.rs

@@ -1,12 +1,14 @@
 mod common;
 mod dist;
 mod mocked;
+mod run;
 mod toolkits_parser;
 mod vendor;
 
 use anyhow::{anyhow, Context, Result};
 use dist::DIST_HELP;
-use mocked::{installation, manager, server};
+use mocked::server;
+use run::RunMode;
 use std::env;
 use std::io::{stdout, Write};
 use std::path::PathBuf;
@@ -21,23 +23,12 @@ Options:
     -h, -help       Print this help message
 
 Commands:
-    dist, d         Generate release binaries
-    run-manager     Run in manager mode
+    d, dist         Generate release binaries
+    r, run          Build and run RIM for testing purpose
     vendor          Download packages for offline package build
     mock-server
                     Generate a mocked rustup dist server
 "#;
-
-const MANAGER_MODE_HELP: &str = r#"
-Run with manager mode
-
-Usage: cargo dev run-manager [OPTIONS]
-
-Options:
-        --cli       Run manager mode with commandline interface
-        --gui       Run manager mode with graphical interface (default)
-    -h, -help       Print this help message
-"#;
 const MOCK_HELP: &str = r#"
 Generate a mocked rustup dist server and rim dist server
 
@@ -57,8 +48,8 @@ enum DevCmd {
         dist_targets: Vec<String>,
         name: Option<String>,
     },
-    RunManager {
-        no_gui: bool,
+    Run {
+        mode: RunMode,
         args: Vec<String>,
     },
     Mock {
@@ -83,25 +74,7 @@ impl DevCmd {
                 dist_targets,
                 name,
             } => dist::dist(mode, binary_only, name, build_target, dist_targets)?,
-            Self::RunManager { no_gui, args } => {
-                println!("running manager with args: {args:?}");
-                // replace home env to prevent modifying the actually environment
-                let home = mocked::mocked_home();
-                std::env::set_var("HOME", home);
-                #[cfg(windows)]
-                std::env::set_var("USERPROFILE", home);
-
-                // a mocked server is needed to run most of function in manager
-                server::generate_rim_server_files()?;
-
-                // generate a fake manager binary with higher version so we
-                // can test the self update.
-                if args.iter().any(|arg| arg == "update") {
-                    manager::generate()?;
-                }
-
-                installation::generate_and_run_manager(no_gui, &args)?;
-            }
+            Self::Run { mode, args } => mode.run(&args)?,
             Self::Vendor {
                 mode,
                 name,
@@ -203,18 +176,21 @@ fn main() -> Result<ExitCode> {
                 clear,
             }
         }
-        "run-manager" => {
+        "run" => {
             let mut is_extra_arg = false;
             let mut extra_args = vec![];
-            let mut no_gui = false;
+            let mut mode = RunMode::default();
 
             while let Some(arg) = args.next().as_deref() {
                 match arg {
                     "-h" | "--help" if !is_extra_arg => {
-                        writeln!(&mut stdout, "{MANAGER_MODE_HELP}")?;
+                        writeln!(&mut stdout, "{}", run::RUN_HELP)?;
                         return Ok(ExitCode::SUCCESS);
                     }
-                    "--cli" => no_gui = true,
+                    "-c" | "--cli" => mode.set_no_gui(true),
+                    "-g" | "--gui" => mode.set_no_gui(false),
+                    "-i" | "--installer" => mode.switch_to_installer(),
+                    "-m" | "--manager" => mode.switch_to_manager(),
                     "--" if !is_extra_arg => is_extra_arg = true,
                     a => {
                         if is_extra_arg {
@@ -224,8 +200,8 @@ fn main() -> Result<ExitCode> {
                 }
             }
 
-            DevCmd::RunManager {
-                no_gui,
+            DevCmd::Run {
+                mode,
                 args: extra_args,
             }
         }

rim_dev/src/mocked/installation.rs

@@ -4,6 +4,7 @@ use crate::common::{self, pnpm_cmd};
 
 use super::TOOLKIT_NAME;
 use anyhow::{bail, Result};
+use rim_common::{build_config, exe};
 use std::{env::consts::EXE_SUFFIX, fs, path::PathBuf, process::Command};
 
 struct FakeInstallation {
@@ -36,28 +37,20 @@ paths = ['{0}/tools/mingw64']
     }
 
     fn generate_manager_bin(&mut self, no_gui: bool) -> Result<()> {
-        let (mut cmd, src_bin, dest_bin) = if no_gui {
+        let (mut cmd, src_bin) = if no_gui {
             // use cargo build
             let mut cmd = Command::new("cargo");
             cmd.arg("build");
 
-            (
-                cmd,
-                format!("rim-cli{EXE_SUFFIX}"),
-                format!("manager-cli{EXE_SUFFIX}"),
-            )
+            (cmd, format!("rim-cli{EXE_SUFFIX}"))
         } else {
             common::install_gui_deps();
 
             // use tauri-cli under rim_gui dir
             let mut cmd = pnpm_cmd();
             cmd.args(["run", "tauri", "build", "-d"]);
 
-            (
-                cmd,
-                format!("rim-gui{EXE_SUFFIX}"),
-                format!("manager{EXE_SUFFIX}"),
-            )
+            (cmd, format!("rim-gui{EXE_SUFFIX}"))
         };
 
         // build rim
@@ -67,6 +60,7 @@ paths = ['{0}/tools/mingw64']
         }
 
         let build_artifact = super::debug_dir().join(src_bin);
+        let dest_bin = exe!(build_config().app_name());
         let dest_path = super::install_dir().join(dest_bin);
         // make a copy of rim as manager binary to the fake installation root
         fs::copy(build_artifact, &dest_path)?;

rim_dev/src/run.rs

@@ -0,0 +1,96 @@
+use std::process::Command;
+
+use anyhow::{bail, Result};
+
+use crate::{
+    common,
+    mocked::{self, installation, manager, server},
+};
+
+pub(super) const RUN_HELP: &str = r#"
+Build and run RIM for testing purpose
+
+Usage: cargo dev run [OPTIONS]
+
+Options:
+    -c, --cli       Run with commandline interface
+    -g, --gui       Run with graphical interface (default)
+    -i, --installer
+                    Run RIM in installer mode (default)
+    -m, --manager   Run RIM in manager mode
+    -h, -help       Print this help message
+"#;
+
+#[derive(Debug, Clone, Copy)]
+pub(super) enum RunMode {
+    Manager { no_gui: bool },
+    Installer { no_gui: bool },
+}
+
+impl Default for RunMode {
+    fn default() -> Self {
+        Self::Installer { no_gui: false }
+    }
+}
+
+impl RunMode {
+    pub(super) fn switch_to_manager(&mut self) {
+        match self {
+            Self::Installer { no_gui } => *self = Self::Manager { no_gui: *no_gui },
+            Self::Manager { .. } => (),
+        }
+    }
+    pub(super) fn switch_to_installer(&mut self) {
+        match self {
+            Self::Installer { .. } => (),
+            Self::Manager { no_gui } => *self = Self::Installer { no_gui: *no_gui },
+        }
+    }
+    pub(super) fn set_no_gui(&mut self, yes: bool) {
+        match self {
+            Self::Manager { no_gui } | Self::Installer { no_gui } => *no_gui = yes,
+        }
+    }
+    pub(super) fn run(&self, args: &[String]) -> Result<()> {
+        println!("running with args: {args:?}");
+
+        // replace home env to prevent modifying the actually HOME var
+        let home = mocked::mocked_home();
+        std::env::set_var("HOME", home);
+        #[cfg(windows)]
+        std::env::set_var("USERPROFILE", home);
+
+        match self {
+            Self::Installer { no_gui } => {
+                let status = if *no_gui {
+                    Command::new("cargo")
+                        .args(["run", "--"])
+                        .args(args)
+                        .status()?
+                } else {
+                    common::pnpm_cmd()
+                        .args(["run", "tauri", "dev", "--"])
+                        .args(args)
+                        .status()?
+                };
+
+                if !status.success() {
+                    bail!("unable to run rim in installer mode");
+                }
+            }
+            Self::Manager { no_gui } => {
+                // a mocked server is needed to run most of function in manager
+                server::generate_rim_server_files()?;
+
+                // generate a fake manager binary with higher version so we
+                // can test the self update.
+                if args.iter().any(|arg| arg == "update") {
+                    manager::generate()?;
+                }
+
+                installation::generate_and_run_manager(*no_gui, args)?;
+            }
+        }
+        Ok(())
+    }
+}