serokell/deploy-rs
1
1
Fork 0
mirror of https://github.com/serokell/deploy-rs.git synced 2024-11-22 05:04:13 +03:00
Code Issues Projects Releases Wiki Activity

General code cleanup

Browse Source
This commit is contained in:
notgne2 2021-08-04 01:04:23 -07:00
parent d72174307d
commit e5546f9c25
No known key found for this signature in database
GPG Key ID: BB661E172B42A7F8
5 changed files with 117 additions and 130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

88
src/bin/activate.rs
View File

@ -95,23 +95,23 @@ struct RevokeOpts {
#[derive(Error, Debug)]
pub enum DeactivateError {
#[error("Failed to execute the rollback command: {0}")]
RollbackError(std::io::Error),
Rollback(std::io::Error),
#[error("The rollback resulted in a bad exit code: {0:?}")]
RollbackExitError(Option<i32>),
RollbackExit(Option<i32>),
#[error("Failed to run command for listing generations: {0}")]
ListGenError(std::io::Error),
ListGen(std::io::Error),
#[error("Command for listing generations resulted in a bad exit code: {0:?}")]
ListGenExitError(Option<i32>),
ListGenExit(Option<i32>),
#[error("Error converting generation list output to utf8: {0}")]
DecodeListGenUtf8Error(#[from] std::string::FromUtf8Error),
DecodeListGenUtf8(std::string::FromUtf8Error),
#[error("Failed to run command for deleting generation: {0}")]
DeleteGenError(std::io::Error),
DeleteGen(std::io::Error),
#[error("Command for deleting generations resulted in a bad exit code: {0:?}")]
DeleteGenExitError(Option<i32>),
DeleteGenExit(Option<i32>),
#[error("Failed to run command for re-activating the last generation: {0}")]
ReactivateError(std::io::Error),
Reactivate(std::io::Error),
#[error("Command for re-activating the last generation resulted in a bad exit code: {0:?}")]
ReactivateExitError(Option<i32>),
ReactivateExit(Option<i32>),
}
pub async fn deactivate(profile_path: &str) -> Result<(), DeactivateError> {
@ -123,11 +123,11 @@ pub async fn deactivate(profile_path: &str) -> Result<(), DeactivateError> {
.arg("--rollback")
.status()
.await
.map_err(DeactivateError::RollbackError)?;
.map_err(DeactivateError::Rollback)?;
match nix_env_rollback_exit_status.code() {
Some(0) => (),
a => return Err(DeactivateError::RollbackExitError(a)),
a => return Err(DeactivateError::RollbackExit(a)),
};
debug!("Listing generations");
@ -138,14 +138,15 @@ pub async fn deactivate(profile_path: &str) -> Result<(), DeactivateError> {
.arg("--list-generations")
.output()
.await
.map_err(DeactivateError::ListGenError)?;
.map_err(DeactivateError::ListGen)?;
match nix_env_list_generations_out.status.code() {
Some(0) => (),
a => return Err(DeactivateError::ListGenExitError(a)),
a => return Err(DeactivateError::ListGenExit(a)),
};
let generations_list = String::from_utf8(nix_env_list_generations_out.stdout)?;
let generations_list = String::from_utf8(nix_env_list_generations_out.stdout)
.map_err(DeactivateError::DecodeListGenUtf8)?;
let last_generation_line = generations_list
.lines()
@ -167,11 +168,11 @@ pub async fn deactivate(profile_path: &str) -> Result<(), DeactivateError> {
.arg(last_generation_id)
.status()
.await
.map_err(DeactivateError::DeleteGenError)?;
.map_err(DeactivateError::DeleteGen)?;
match nix_env_delete_generation_exit_status.code() {
Some(0) => (),
a => return Err(DeactivateError::DeleteGenExitError(a)),
a => return Err(DeactivateError::DeleteGenExit(a)),
};
info!("Attempting to re-activate the last generation");
@ -181,11 +182,11 @@ pub async fn deactivate(profile_path: &str) -> Result<(), DeactivateError> {
.current_dir(&profile_path)
.status()
.await
.map_err(DeactivateError::ReactivateError)?;
.map_err(DeactivateError::Reactivate)?;
match re_activate_exit_status.code() {
Some(0) => (),
a => return Err(DeactivateError::ReactivateExitError(a)),
a => return Err(DeactivateError::ReactivateExit(a)),
};
Ok(())
@ -194,15 +195,11 @@ pub async fn deactivate(profile_path: &str) -> Result<(), DeactivateError> {
#[derive(Error, Debug)]
pub enum ActivationConfirmationError {
#[error("Failed to create activation confirmation directory: {0}")]
CreateConfirmDirError(std::io::Error),
CreateConfirmDir(std::io::Error),
#[error("Failed to create activation confirmation file: {0}")]
CreateConfirmFileError(std::io::Error),
#[error("Failed to create file system watcher instance: {0}")]
CreateWatcherError(notify::Error),
#[error("Error forking process: {0}")]
ForkError(i32),
CreateConfirmFile(std::io::Error),
#[error("Could not watch for activation sentinel: {0}")]
WatcherError(#[from] notify::Error),
Watcher(#[from] notify::Error),
}
#[derive(Error, Debug)]
@ -212,7 +209,7 @@ pub enum DangerZoneError {
#[error("inotify stream ended without activation confirmation")]
NoConfirmation,
#[error("inotify encountered an error: {0}")]
WatchError(notify::Error),
Watch(notify::Error),
}
async fn danger_zone(
@ -223,7 +220,7 @@ async fn danger_zone(
match timeout(Duration::from_secs(confirm_timeout as u64), events.recv()).await {
Ok(Some(Ok(()))) => Ok(()),
Ok(Some(Err(e))) => Err(DangerZoneError::WatchError(e)),
Ok(Some(Err(e))) => Err(DangerZoneError::Watch(e)),
Ok(None) => Err(DangerZoneError::NoConfirmation),
Err(_) => Err(DangerZoneError::TimesUp),
}
@ -242,14 +239,14 @@ pub async fn activation_confirmation(
if let Some(parent) = Path::new(&lock_path).parent() {
fs::create_dir_all(parent)
.await
.map_err(ActivationConfirmationError::CreateConfirmDirError)?;
.map_err(ActivationConfirmationError::CreateConfirmDir)?;
}
debug!("Creating canary file");
fs::File::create(&lock_path)
.await
.map_err(ActivationConfirmationError::CreateConfirmFileError)?;
.map_err(ActivationConfirmationError::CreateConfirmFile)?;
debug!("Creating notify watcher");
@ -342,20 +339,20 @@ pub async fn wait(temp_path: String, closure: String) -> Result<(), WaitError> {
#[derive(Error, Debug)]
pub enum ActivateError {
#[error("Failed to execute the command for setting profile: {0}")]
SetProfileError(std::io::Error),
SetProfile(std::io::Error),
#[error("The command for setting profile resulted in a bad exit code: {0:?}")]
SetProfileExitError(Option<i32>),
SetProfileExit(Option<i32>),
#[error("Failed to execute the activation script: {0}")]
RunActivateError(std::io::Error),
RunActivate(std::io::Error),
#[error("The activation script resulted in a bad exit code: {0:?}")]
RunActivateExitError(Option<i32>),
RunActivateExit(Option<i32>),
#[error("There was an error de-activating after an error was encountered: {0}")]
DeactivateError(#[from] DeactivateError),
Deactivate(#[from] DeactivateError),
#[error("Failed to get activation confirmation: {0}")]
ActivationConfirmationError(#[from] ActivationConfirmationError),
ActivationConfirmation(#[from] ActivationConfirmationError),
}
pub async fn activate(
@ -376,14 +373,14 @@ pub async fn activate(
.arg(&closure)
.status()
.await
.map_err(ActivateError::SetProfileError)?;
.map_err(ActivateError::SetProfile)?;
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::SetProfileExit(a));
}
};
}
@ -402,7 +399,7 @@ pub async fn activate(
.current_dir(activation_location)
.status()
.await
.map_err(ActivateError::RunActivateError)
.map_err(ActivateError::RunActivate)
{
Ok(x) => x,
Err(e) => {
@ -420,7 +417,7 @@ pub async fn activate(
if auto_rollback {
deactivate(&profile_path).await?;
}
return Err(ActivateError::RunActivateExitError(a));
return Err(ActivateError::RunActivateExit(a));
}
};
@ -437,7 +434,7 @@ pub async fn activate(
Ok(()) => {}
Err(err) => {
deactivate(&profile_path).await?;
return Err(ActivateError::ActivationConfirmationError(err));
return Err(ActivateError::ActivationConfirmation(err));
}
};
}
@ -446,12 +443,7 @@ pub async fn activate(
Ok(())
}
#[derive(Error, Debug)]
pub enum RevokeError {
#[error("There was an error de-activating after an error was encountered: {0}")]
DeactivateError(#[from] DeactivateError),
}
async fn revoke(profile_path: String) -> Result<(), RevokeError> {
async fn revoke(profile_path: String) -> Result<(), DeactivateError> {
deactivate(profile_path.as_str()).await?;
Ok(())
}
@ -462,7 +454,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
let mut signals = Signals::new(&[SIGHUP])?;
std::thread::spawn(move || {
for _ in signals.forever() {
println!("Received NOHUP - ignoring...");
println!("Received SIGHUP - ignoring...");
}
});
@ -471,7 +463,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
deploy::init_logger(
opts.debug_logs,
opts.log_dir.as_deref(),
match opts.subcmd {
&match opts.subcmd {
SubCommand::Activate(_) => deploy::LoggerType::Activate,
SubCommand::Wait(_) => deploy::LoggerType::Wait,
SubCommand::Revoke(_) => deploy::LoggerType::Revoke,

47
src/cli.rs
View File

@ -6,7 +6,7 @@
use std::collections::HashMap;
use std::io::{stdin, stdout, Write};
use clap::{Clap, ArgMatches, FromArgMatches};
use clap::{ArgMatches, Clap, FromArgMatches};
use crate as deploy;
@ -127,16 +127,13 @@ async fn check_deployment(
false => Command::new("nix-build"),
};
match supports_flakes {
true => {
check_command.arg("flake").arg("check").arg(repo);
}
false => {
check_command.arg("-E")
if supports_flakes {
check_command.arg("flake").arg("check").arg(repo);
} else {
check_command.arg("-E")
.arg("--no-out-link")
.arg(format!("let r = import {}/.; x = (if builtins.isFunction r then (r {{}}) else r); in if x ? checks then x.checks.${{builtins.currentSystem}} else {{}}", repo));
}
};
}
for extra_arg in extra_build_args {
check_command.arg(extra_arg);
@ -420,16 +417,16 @@ async fn run_deploy(
(Some(node_name), Some(profile_name)) => {
let node = match data.nodes.get(node_name) {
Some(x) => x,
None => Err(RunDeployError::NodeNotFound(node_name.to_owned()))?,
None => return Err(RunDeployError::NodeNotFound(node_name.clone())),
};
let profile = match node.node_settings.profiles.get(profile_name) {
Some(x) => x,
None => Err(RunDeployError::ProfileNotFound(profile_name.to_owned()))?,
None => return Err(RunDeployError::ProfileNotFound(profile_name.clone())),
};
vec![(
&deploy_flake,
&data,
deploy_flake,
data,
(node_name.as_str(), node),
(profile_name.as_str(), profile),
)]
@ -437,7 +434,7 @@ async fn run_deploy(
(Some(node_name), None) => {
let node = match data.nodes.get(node_name) {
Some(x) => x,
None => return Err(RunDeployError::NodeNotFound(node_name.to_owned())),
None => return Err(RunDeployError::NodeNotFound(node_name.clone())),
};
let mut profiles_list: Vec<(&str, &deploy::data::Profile)> = Vec::new();
@ -451,14 +448,12 @@ async fn run_deploy(
let profile = match node.node_settings.profiles.get(profile_name) {
Some(x) => x,
None => {
return Err(RunDeployError::ProfileNotFound(
profile_name.to_owned(),
))
return Err(RunDeployError::ProfileNotFound(profile_name.clone()))
}
};
if !profiles_list.iter().any(|(n, _)| n == profile_name) {
profiles_list.push((&profile_name, profile));
profiles_list.push((profile_name, profile));
}
}
@ -483,13 +478,13 @@ async fn run_deploy(
Some(x) => x,
None => {
return Err(RunDeployError::ProfileNotFound(
profile_name.to_owned(),
profile_name.clone(),
))
}
};
if !profiles_list.iter().any(|(n, _)| n == profile_name) {
profiles_list.push((&profile_name, profile));
profiles_list.push((profile_name, profile));
}
}
@ -525,7 +520,7 @@ async fn run_deploy(
node_name,
profile,
profile_name,
&cmd_overrides,
cmd_overrides,
debug_logs,
log_dir.as_deref(),
);
@ -546,8 +541,8 @@ async fn run_deploy(
supports_flakes,
check_sigs,
repo: deploy_flake.repo,
deploy_data: &deploy_data,
deploy_defs: &deploy_defs,
deploy_data,
deploy_defs,
keep_result,
result_path,
extra_build_args,
@ -616,13 +611,13 @@ pub async fn run(args: Option<&ArgMatches>) -> Result<(), RunError> {
deploy::init_logger(
opts.debug_logs,
opts.log_dir.as_deref(),
deploy::LoggerType::Deploy,
&deploy::LoggerType::Deploy,
)?;
let deploys = opts
.clone()
.targets
.unwrap_or_else(|| vec![opts.clone().target.unwrap_or(".".to_string())]);
.unwrap_or_else(|| vec![opts.clone().target.unwrap_or_else(|| ".".to_string())]);
let deploy_flakes: Vec<DeployFlake> = deploys
.iter()
@ -649,7 +644,7 @@ pub async fn run(args: Option<&ArgMatches>) -> Result<(), RunError> {
}
if !opts.skip_checks {
for deploy_flake in deploy_flakes.iter() {
for deploy_flake in &deploy_flakes {
check_deployment(supports_flakes, deploy_flake.repo, &opts.extra_build_args).await?;
}
}

66
src/deploy.rs
View File

@ -24,7 +24,7 @@ struct ActivateCommandData<'a> {
dry_activate: bool,
}
fn build_activate_command(data: ActivateCommandData) -> String {
fn build_activate_command(data: &ActivateCommandData) -> String {
let mut self_activate_command = format!("{}/activate-rs", data.closure);
if data.debug_logs {
@ -78,7 +78,7 @@ fn test_activation_command_builder() {
let log_dir = Some("/tmp/something.txt");
assert_eq!(
build_activate_command(ActivateCommandData {
build_activate_command(&ActivateCommandData {
sudo: &sudo,
profile_path,
closure,
@ -103,7 +103,7 @@ struct WaitCommandData<'a> {
log_dir: Option<&'a str>,
}
fn build_wait_command(data: WaitCommandData) -> String {
fn build_wait_command(data: &WaitCommandData) -> String {
let mut self_activate_command = format!("{}/activate-rs", data.closure);
if data.debug_logs {
@ -135,7 +135,7 @@ fn test_wait_command_builder() {
let log_dir = Some("/tmp/something.txt");
assert_eq!(
build_wait_command(WaitCommandData {
build_wait_command(&WaitCommandData {
sudo: &sudo,
closure,
temp_path,
@ -155,7 +155,7 @@ struct RevokeCommandData<'a> {
log_dir: Option<&'a str>,
}
fn build_revoke_command(data: RevokeCommandData) -> String {
fn build_revoke_command(data: &RevokeCommandData) -> String {
let mut self_activate_command = format!("{}/activate-rs", data.closure);
if data.debug_logs {
@ -184,7 +184,7 @@ fn test_revoke_command_builder() {
let log_dir = Some("/tmp/something.txt");
assert_eq!(
build_revoke_command(RevokeCommandData {
build_revoke_command(&RevokeCommandData {
sudo: &sudo,
closure,
profile_path,
@ -199,11 +199,11 @@ fn test_revoke_command_builder() {
#[derive(Error, Debug)]
pub enum ConfirmProfileError {
#[error("Failed to run confirmation command over SSH (the server should roll back): {0}")]
SSHConfirmError(std::io::Error),
SSHConfirm(std::io::Error),
#[error(
"Confirming activation over SSH resulted in a bad exit code (the server should roll back): {0:?}"
)]
SSHConfirmExitError(Option<i32>),
SSHConfirmExit(Option<i32>),
}
pub async fn confirm_profile(
@ -235,11 +235,11 @@ pub async fn confirm_profile(
.arg(confirm_command)
.status()
.await
.map_err(ConfirmProfileError::SSHConfirmError)?;
.map_err(ConfirmProfileError::SSHConfirm)?;
match ssh_confirm_exit_status.code() {
Some(0) => (),
a => return Err(ConfirmProfileError::SSHConfirmExitError(a)),
a => return Err(ConfirmProfileError::SSHConfirmExit(a)),
};
info!("Deployment confirmed.");
@ -250,20 +250,20 @@ pub async fn confirm_profile(
#[derive(Error, Debug)]
pub enum DeployProfileError {
#[error("Failed to spawn activation command over SSH: {0}")]
SSHSpawnActivateError(std::io::Error),
SSHSpawnActivate(std::io::Error),
#[error("Failed to run activation command over SSH: {0}")]
SSHActivateError(std::io::Error),
SSHActivate(std::io::Error),
#[error("Activating over SSH resulted in a bad exit code: {0:?}")]
SSHActivateExitError(Option<i32>),
SSHActivateExit(Option<i32>),
#[error("Failed to run wait command over SSH: {0}")]
SSHWaitError(std::io::Error),
SSHWait(std::io::Error),
#[error("Waiting over SSH resulted in a bad exit code: {0:?}")]
SSHWaitExitError(Option<i32>),
SSHWaitExit(Option<i32>),
#[error("Error confirming deployment: {0}")]
ConfirmError(#[from] ConfirmProfileError),
Confirm(#[from] ConfirmProfileError),
}
pub async fn deploy_profile(
@ -289,7 +289,7 @@ pub async fn deploy_profile(
let auto_rollback = deploy_data.merged_settings.auto_rollback.unwrap_or(true);
let self_activate_command = build_activate_command(ActivateCommandData {
let self_activate_command = build_activate_command(&ActivateCommandData {
sudo: &deploy_defs.sudo,
profile_path: &deploy_defs.profile_path,
closure: &deploy_data.profile.profile_settings.path,
@ -323,11 +323,11 @@ pub async fn deploy_profile(
.arg(self_activate_command)
.status()
.await
.map_err(DeployProfileError::SSHActivateError)?;
.map_err(DeployProfileError::SSHActivate)?;
match ssh_activate_exit_status.code() {
Some(0) => (),
a => return Err(DeployProfileError::SSHActivateExitError(a)),
a => return Err(DeployProfileError::SSHActivateExit(a)),
};
if dry_activate {
@ -336,7 +336,7 @@ pub async fn deploy_profile(
info!("Success activating, done!");
}
} else {
let self_wait_command = build_wait_command(WaitCommandData {
let self_wait_command = build_wait_command(&WaitCommandData {
sudo: &deploy_defs.sudo,
closure: &deploy_data.profile.profile_settings.path,
temp_path: &temp_path,
@ -349,7 +349,7 @@ pub async fn deploy_profile(
let ssh_activate = ssh_activate_command
.arg(self_activate_command)
.spawn()
.map_err(DeployProfileError::SSHSpawnActivateError)?;
.map_err(DeployProfileError::SSHSpawnActivate)?;
info!("Creating activation waiter");
@ -367,10 +367,10 @@ pub async fn deploy_profile(
let o = ssh_activate.wait_with_output().await;
let maybe_err = match o {
Err(x) => Some(DeployProfileError::SSHActivateError(x)),
Err(x) => Some(DeployProfileError::SSHActivate(x)),
Ok(ref x) => match x.status.code() {
Some(0) => None,
a => Some(DeployProfileError::SSHActivateExitError(a)),
a => Some(DeployProfileError::SSHActivateExit(a)),
},
};
@ -383,9 +383,9 @@ pub async fn deploy_profile(
tokio::select! {
x = ssh_wait_command.arg(self_wait_command).status() => {
debug!("Wait command ended");
match x.map_err(DeployProfileError::SSHWaitError)?.code() {
match x.map_err(DeployProfileError::SSHWait)?.code() {
Some(0) => (),
a => return Err(DeployProfileError::SSHWaitExitError(a)),
a => return Err(DeployProfileError::SSHWaitExit(a)),
};
},
x = recv_activate => {
@ -407,21 +407,21 @@ pub async fn deploy_profile(
#[derive(Error, Debug)]
pub enum RevokeProfileError {
#[error("Failed to spawn revocation command over SSH: {0}")]
SSHSpawnRevokeError(std::io::Error),
SSHSpawnRevoke(std::io::Error),
#[error("Error revoking deployment: {0}")]
SSHRevokeError(std::io::Error),
SSHRevoke(std::io::Error),
#[error("Revoking over SSH resulted in a bad exit code: {0:?}")]
SSHRevokeExitError(Option<i32>),
SSHRevokeExit(Option<i32>),
#[error("Deployment data invalid: {0}")]
InvalidDeployDataDefsError(#[from] DeployDataDefsError),
InvalidDeployDataDefs(#[from] DeployDataDefsError),
}
pub async fn revoke(
deploy_data: &crate::DeployData<'_>,
deploy_defs: &crate::DeployDefs,
) -> Result<(), RevokeProfileError> {
let self_revoke_command = build_revoke_command(RevokeCommandData {
let self_revoke_command = build_revoke_command(&RevokeCommandData {
sudo: &deploy_defs.sudo,
closure: &deploy_data.profile.profile_settings.path,
profile_path: &deploy_data.get_profile_path()?,
@ -448,15 +448,15 @@ pub async fn revoke(
let ssh_revoke = ssh_activate_command
.arg(self_revoke_command)
.spawn()
.map_err(RevokeProfileError::SSHSpawnRevokeError)?;
.map_err(RevokeProfileError::SSHSpawnRevoke)?;
let result = ssh_revoke.wait_with_output().await;
match result {
Err(x) => Err(RevokeProfileError::SSHRevokeError(x)),
Err(x) => Err(RevokeProfileError::SSHRevoke(x)),
Ok(ref x) => match x.status.code() {
Some(0) => Ok(()),
a => Err(RevokeProfileError::SSHRevokeExitError(a)),
a => Err(RevokeProfileError::SSHRevokeExit(a)),
},
}
}

6
src/lib.rs
View File

@ -18,7 +18,7 @@ pub fn make_lock_path(temp_path: &str, closure: &str) -> String {
format!("{}/deploy-rs-canary-{}", temp_path, lock_hash)
}
fn make_emoji(level: log::Level) -> &'static str {
const fn make_emoji(level: log::Level) -> &'static str {
match level {
log::Level::Error => "❌",
log::Level::Warn => "⚠️",
@ -102,9 +102,9 @@ pub enum LoggerType {
pub fn init_logger(
debug_logs: bool,
log_dir: Option<&str>,
logger_type: LoggerType,
logger_type: &LoggerType,
) -> Result<(), FlexiLoggerError> {
let logger_formatter = match logger_type {
let logger_formatter = match &logger_type {
LoggerType::Deploy => logger_formatter_deploy,
LoggerType::Activate => logger_formatter_activate,
LoggerType::Wait => logger_formatter_wait,

40
src/push.rs
View File

@ -12,19 +12,19 @@ use tokio::process::Command;
#[derive(Error, Debug)]
pub enum PushProfileError {
#[error("Failed to run Nix show-derivation command: {0}")]
ShowDerivationError(std::io::Error),
ShowDerivation(std::io::Error),
#[error("Nix show-derivation command resulted in a bad exit code: {0:?}")]
ShowDerivationExitError(Option<i32>),
ShowDerivationExit(Option<i32>),
#[error("Nix show-derivation command output contained an invalid UTF-8 sequence: {0}")]
ShowDerivationUtf8Error(std::str::Utf8Error),
ShowDerivationUtf8(std::str::Utf8Error),
#[error("Failed to parse the output of nix show-derivation: {0}")]
ShowDerivationParseError(serde_json::Error),
ShowDerivationParse(serde_json::Error),
#[error("Nix show-derivation output is empty")]
ShowDerivationEmpty,
#[error("Failed to run Nix build command: {0}")]
BuildError(std::io::Error),
Build(std::io::Error),
#[error("Nix build command resulted in a bad exit code: {0:?}")]
BuildExitError(Option<i32>),
BuildExit(Option<i32>),
#[error(
"Activation script deploy-rs-activate does not exist in profile.\n\
Did you forget to use deploy-rs#lib.<...>.activate.<...> on your profile path?"
@ -34,13 +34,13 @@ pub enum PushProfileError {
Is there a mismatch in deploy-rs used in the flake you're deploying and deploy-rs command you're running?")]
ActivateRsDoesntExist,
#[error("Failed to run Nix sign command: {0}")]
SignError(std::io::Error),
Sign(std::io::Error),
#[error("Nix sign command resulted in a bad exit code: {0:?}")]
SignExitError(Option<i32>),
SignExit(Option<i32>),
#[error("Failed to run Nix copy command: {0}")]
CopyError(std::io::Error),
Copy(std::io::Error),
#[error("Nix copy command resulted in a bad exit code: {0:?}")]
CopyExitError(Option<i32>),
CopyExit(Option<i32>),
}
pub struct PushProfileData<'a> {
@ -70,18 +70,18 @@ pub async fn push_profile(data: PushProfileData<'_>) -> Result<(), PushProfileEr
let show_derivation_output = show_derivation_command
.output()
.await
.map_err(PushProfileError::ShowDerivationError)?;
.map_err(PushProfileError::ShowDerivation)?;
match show_derivation_output.status.code() {
Some(0) => (),
a => return Err(PushProfileError::ShowDerivationExitError(a)),
a => return Err(PushProfileError::ShowDerivationExit(a)),
};
let derivation_info: HashMap<&str, serde_json::value::Value> = serde_json::from_str(
std::str::from_utf8(&show_derivation_output.stdout)
.map_err(PushProfileError::ShowDerivationUtf8Error)?,
.map_err(PushProfileError::ShowDerivationUtf8)?,
)
.map_err(PushProfileError::ShowDerivationParseError)?;
.map_err(PushProfileError::ShowDerivationParse)?;
let derivation_name = derivation_info
.keys()
@ -127,11 +127,11 @@ pub async fn push_profile(data: PushProfileData<'_>) -> Result<(), PushProfileEr
.stdout(Stdio::null())
.status()
.await
.map_err(PushProfileError::BuildError)?;
.map_err(PushProfileError::Build)?;
match build_exit_status.code() {
Some(0) => (),
a => return Err(PushProfileError::BuildExitError(a)),
a => return Err(PushProfileError::BuildExit(a)),
};
if !Path::new(
@ -172,11 +172,11 @@ pub async fn push_profile(data: PushProfileData<'_>) -> Result<(), PushProfileEr
.arg(&data.deploy_data.profile.profile_settings.path)
.status()
.await
.map_err(PushProfileError::SignError)?;
.map_err(PushProfileError::Sign)?;
match sign_exit_status.code() {
Some(0) => (),
a => return Err(PushProfileError::SignExitError(a)),
a => return Err(PushProfileError::SignExit(a)),
};
}
@ -218,11 +218,11 @@ pub async fn push_profile(data: PushProfileData<'_>) -> Result<(), PushProfileEr
.env("NIX_SSHOPTS", ssh_opts_str)
.status()
.await
.map_err(PushProfileError::CopyError)?;
.map_err(PushProfileError::Copy)?;
match copy_exit_status.code() {
Some(0) => (),
a => return Err(PushProfileError::CopyExitError(a)),
a => return Err(PushProfileError::CopyExit(a)),
};
Ok(())