refactor activate step a bit

wire/lib/src/hive/steps/activate.rs

···
 use crate::{
     HiveLibError,
     commands::{CommandArguments, WireCommandChip, run_command},
-    errors::{ActivationError, NetworkError},
+    errors::{ActivationError, CommandError, NetworkError},
     hive::node::{Context, ExecuteStep, Goal, SwitchToConfigurationGoal},
 };
 
···
     info!("Set system profile");
 
     Ok(())
+}
+
+async fn reboot(ctx: &Context<'_>) -> Result<(), HiveLibError> {
+    if !ctx.reboot {
+        return Ok(());
+    }
+
+    if ctx.should_apply_locally {
+        error!("Refusing to reboot local machine!");
+
+        return Ok(());
+    }
+
+    warn!("Rebooting {name}!", name = ctx.name);
+
+    let reboot = run_command(
+        &CommandArguments::new("reboot now", ctx.modifiers)
+            .log_stdout()
+            .on_target(Some(&ctx.node.target))
+            .elevated(ctx.node),
+    )
+    .await?;
+
+    // consume result, impossible to know if the machine failed to reboot or we
+    // simply disconnected
+    let _ = reboot
+        .wait_till_success()
+        .await
+        .map_err(HiveLibError::CommandError)?;
+
+    info!("Rebooted {name}, waiting to reconnect...", name = ctx.name);
+
+    if wait_for_ping(ctx).await.is_ok() {
+        return Ok(());
+    }
+
+    error!(
+        "Failed to get regain connection to {name} via {host} after reboot.",
+        name = ctx.name,
+        host = ctx.node.target.get_preferred_host()?
+    );
+
+    return Err(HiveLibError::NetworkError(
+        NetworkError::HostUnreachableAfterReboot(ctx.node.target.get_preferred_host()?.to_string()),
+    ));
+}
+
+async fn reconnect(
+    ctx: &Context<'_>,
+    goal: &SwitchToConfigurationGoal,
+    error: CommandError,
+) -> Result<(), HiveLibError> {
+    warn!(
+        "Activation command for {name} exited unsuccessfully.",
+        name = ctx.name
+    );
+
+    // Bail if the command couldn't of broken the system
+    // and don't try to regain connection to localhost
+    if matches!(goal, SwitchToConfigurationGoal::DryActivate) || ctx.should_apply_locally {
+        return Err(HiveLibError::ActivationError(
+            ActivationError::SwitchToConfigurationError(*goal, ctx.name.clone(), error),
+        ));
+    }
+
+    if wait_for_ping(ctx).await.is_ok() {
+        return Err(HiveLibError::ActivationError(
+            ActivationError::SwitchToConfigurationError(*goal, ctx.name.clone(), error),
+        ));
+    }
+
+    error!(
+        "Failed to get regain connection to {name} via {host} after {goal} activation.",
+        name = ctx.name,
+        host = ctx.node.target.get_preferred_host()?
+    );
+
+    return Err(HiveLibError::NetworkError(
+        NetworkError::HostUnreachableAfterReboot(ctx.node.target.get_preferred_host()?.to_string()),
+    ));
 }
 
 impl ExecuteStep for SwitchToConfiguration {
···
         let result = child.wait_till_success().await;
 
         match result {
-            Ok(_) => {
-                if !ctx.reboot {
-                    return Ok(());
-                }
-
-                if ctx.should_apply_locally {
-                    error!("Refusing to reboot local machine!");
-
-                    return Ok(());
-                }
-
-                warn!("Rebooting {name}!", name = ctx.name);
-
-                let reboot = run_command(
-                    &CommandArguments::new("reboot now", ctx.modifiers)
-                        .log_stdout()
-                        .on_target(Some(&ctx.node.target))
-                        .elevated(ctx.node),
-                )
-                .await?;
-
-                // consume result, impossible to know if the machine failed to reboot or we
-                // simply disconnected
-                let _ = reboot
-                    .wait_till_success()
-                    .await
-                    .map_err(HiveLibError::CommandError)?;
-
-                info!("Rebooted {name}, waiting to reconnect...", name = ctx.name);
-
-                if wait_for_ping(ctx).await.is_ok() {
-                    return Ok(());
-                }
-
-                error!(
-                    "Failed to get regain connection to {name} via {host} after reboot.",
-                    name = ctx.name,
-                    host = ctx.node.target.get_preferred_host()?
-                );
-
-                return Err(HiveLibError::NetworkError(
-                    NetworkError::HostUnreachableAfterReboot(
-                        ctx.node.target.get_preferred_host()?.to_string(),
-                    ),
-                ));
-            }
-            Err(error) => {
-                warn!(
-                    "Activation command for {name} exited unsuccessfully.",
-                    name = ctx.name
-                );
-
-                // Bail if the command couldn't of broken the system
-                // and don't try to regain connection to localhost
-                if matches!(goal, SwitchToConfigurationGoal::DryActivate)
-                    || ctx.should_apply_locally
-                {
-                    return Err(HiveLibError::ActivationError(
-                        ActivationError::SwitchToConfigurationError(*goal, ctx.name.clone(), error),
-                    ));
-                }
-
-                if wait_for_ping(ctx).await.is_ok() {
-                    return Err(HiveLibError::ActivationError(
-                        ActivationError::SwitchToConfigurationError(*goal, ctx.name.clone(), error),
-                    ));
-                }
-
-                error!(
-                    "Failed to get regain connection to {name} via {host} after {goal} activation.",
-                    name = ctx.name,
-                    host = ctx.node.target.get_preferred_host()?
-                );
-
-                return Err(HiveLibError::NetworkError(
-                    NetworkError::HostUnreachableAfterReboot(
-                        ctx.node.target.get_preferred_host()?.to_string(),
-                    ),
-                ));
-            }
+            Ok(_) => reboot(ctx).await,
+            Err(error) => reconnect(ctx, goal, error).await,
         }
     }
 }