Add dry activate argument.

2 files changed, 60 insertions, 43 deletions

diff --git a/src/bin/activate.rs b/src/bin/activate.rs
index 947e883..73d064f 100644
--- a/src/bin/activate.rs
+++ b/src/bin/activate.rs
@@ -66,6 +66,10 @@ struct ActivateOpts {
     /// Auto rollback if failure
     #[clap(long)]
     auto_rollback: bool,
+
+    /// Show what will be activated on the machines
+    #[clap(long)]
+    dry_activate: bool,
 }
 
 /// Activate a profile
@@ -348,70 +352,76 @@ pub async fn activate(
     temp_path: String,
     confirm_timeout: u16,
     magic_rollback: bool,
+    dry_activate: bool,
 ) -> Result<(), ActivateError> {
-    info!("Activating profile");
-
-    let nix_env_set_exit_status = Command::new("nix-env")
-        .arg("-p")
-        .arg(&profile_path)
-        .arg("--set")
-        .arg(&closure)
-        .status()
-        .await
-        .map_err(ActivateError::SetProfileError)?;
-
-    match nix_env_set_exit_status.code() {
-        Some(0) => (),
-        a => {
-            if auto_rollback {
-                deactivate(&profile_path).await?;
+    if !dry_activate {
+        info!("Activating profile");
+        let nix_env_set_exit_status = Command::new("nix-env")
+            .arg("-p")
+            .arg(&profile_path)
+            .arg("--set")
+            .arg(&closure)
+            .status()
+            .await
+            .map_err(ActivateError::SetProfileError)?;
+        match nix_env_set_exit_status.code() {
+            Some(0) => (),
+            a => {
+                if auto_rollback && !dry_activate {
+                    deactivate(&profile_path).await?;
+                }
+                return Err(ActivateError::SetProfileExitError(a));
             }
-            return Err(ActivateError::SetProfileExitError(a));
-        }
-    };
+        };
+    }
 
     debug!("Running activation script");
 
     let activate_status = match Command::new(format!("{}/deploy-rs-activate", profile_path))
-        .env("PROFILE", &profile_path)
-        .current_dir(&profile_path)
+        .env("PROFILE", &closure)
+        .env("DRY_ACTIVATE", if dry_activate { "1" } else { "0" })
+        .current_dir(&closure)
         .status()
         .await
         .map_err(ActivateError::RunActivateError)
     {
         Ok(x) => x,
         Err(e) => {
-            if auto_rollback {
+            if auto_rollback && !dry_activate {
                 deactivate(&profile_path).await?;
             }
             return Err(e);
         }
     };
 
-    match activate_status.code() {
-        Some(0) => (),
-        a => {
-            if auto_rollback {
-                deactivate(&profile_path).await?;
+    if !dry_activate {
+        match activate_status.code() {
+            Some(0) => (),
+            a => {
+                if auto_rollback {
+                    deactivate(&profile_path).await?;
+                }
+                return Err(ActivateError::RunActivateExitError(a));
             }
-            return Err(ActivateError::RunActivateExitError(a));
-        }
-    };
+        };
 
-    info!("Activation succeeded!");
+        if !dry_activate {
+            info!("Activation succeeded!");
+        }
 
-    if magic_rollback {
-        info!("Magic rollback is enabled, setting up confirmation hook...");
+        if magic_rollback {
+            info!("Magic rollback is enabled, setting up confirmation hook...");
 
-        match activation_confirmation(profile_path.clone(), temp_path, confirm_timeout, closure)
-            .await
-        {
-            Ok(()) => {}
-            Err(err) => {
-                deactivate(&profile_path).await?;
-                return Err(ActivateError::ActivationConfirmationError(err));
-            }
-        };
+            match activation_confirmation(profile_path.clone(), temp_path, confirm_timeout, closure)
+                .await
+            {
+                Ok(()) => {}
+                Err(err) => {
+                    deactivate(&profile_path).await?;
+                    return Err(ActivateError::ActivationConfirmationError(err));
+                }
+            };
+        }
     }
 
     Ok(())
@@ -446,6 +456,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
             opts.temp_path,
             activate_opts.confirm_timeout,
             activate_opts.magic_rollback,
+            activate_opts.dry_activate,
         )
         .await
         .map_err(|x| Box::new(x) as Box<dyn std::error::Error>),
diff --git a/src/bin/deploy.rs b/src/bin/deploy.rs
index 9c41d25..10e0552 100644
--- a/src/bin/deploy.rs
+++ b/src/bin/deploy.rs
@@ -74,6 +74,9 @@ struct Opts {
     /// Where to store temporary files (only used by magic-rollback)
     #[clap(long)]
     temp_path: Option<String>,
+    /// Show what will be activated on the machines
+    #[clap(long)]
+    dry_activate: bool,
 }
 
 /// Returns if the available Nix installation supports flakes
@@ -379,6 +382,7 @@ async fn run_deploy(
     extra_build_args: &[String],
     debug_logs: bool,
     log_dir: Option<String>,
+    dry_activate: bool,
 ) -> Result<(), RunDeployError> {
     let to_deploy: ToDeploy = match (&deploy_flake.node, &deploy_flake.profile) {
         (Some(node_name), Some(profile_name)) => {
@@ -499,7 +503,7 @@ async fn run_deploy(
     }
 
     for (deploy_data, deploy_defs) in &parts {
-        deploy::deploy::deploy_profile(&deploy_data, &deploy_defs).await?;
+        deploy::deploy::deploy_profile(&deploy_data, &deploy_defs, dry_activate).await?;
     }
 
     Ok(())
@@ -546,6 +550,7 @@ async fn run() -> Result<(), RunError> {
         magic_rollback: opts.magic_rollback,
         temp_path: opts.temp_path,
         confirm_timeout: opts.confirm_timeout,
+        dry_activate: opts.dry_activate,
     };
 
     let supports_flakes = test_flake_support().await.map_err(RunError::FlakeTest)?;
@@ -574,6 +579,7 @@ async fn run() -> Result<(), RunError> {
         &opts.extra_build_args,
         opts.debug_logs,
         opts.log_dir,
+        opts.dry_activate,
     )
     .await?;