cfdns 0.1.0

A Cloudflare Dynamic DNS update tool
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

// Copyright 2025 Matthew Lyon
// SPDX-License-Identifier: Apache-2.0
use crate::config::{Config, ConfigError};
use colored::Colorize;
use inquire::{InquireError, prompt_confirmation};
use miette::{Diagnostic, IntoDiagnostic, Result};
use thiserror::Error;
use tracing::instrument;
use std::{path::{Path, PathBuf}, process::exit};

#[instrument(skip_all, name = "edit")]
pub async fn edit(custom_path: Option<&Path>) -> Result<()> {
    match edit_inner(custom_path) {
        Err(EditError::Aborted) => {
            println!("{}", "Aborted edit configuration.".bold());
            exit(1);
        },
        Err(EditError::ConfigNotFound(path)) => {
            config_not_found(path.as_deref()).await?;
            Ok(())
        },
        others => others
    }?;
    Ok(())
}

fn edit_inner(custom_path: Option<&Path>) -> Result<(), EditError> {
    let mut config = {
        let load = match custom_path {
            Some(custom) => Config::load(custom),
            None => Config::load_default()
        };
        match load {
            Err(ConfigError::NotFound { path: _ } | ConfigError::Missing { path: _ }) => {
                return Err(EditError::ConfigNotFound(custom_path.map(|p| p.to_path_buf())))
            }
            others => others
        }
    }?;

    let mut yaml_text = serde_yaml::to_string(&config).map_err(|source| ConfigError::Yaml{ source })?;
    loop {
        let new_text = inquire::Editor::new("")
            .with_file_extension(".yaml")
            .with_predefined_text(&yaml_text)
            .prompt()?;

        let new_config: Config = match serde_yaml::from_str(&new_text) {
            Ok(c) => c,
            Err(e) => {
                let should_retry = invalid_edit(&e)?;
                if should_retry {
                    yaml_text = new_text;
                    continue;
                } else {
                    return Err(EditError::Aborted)
                }
            }
        };
        config.cloudflare = new_config.cloudflare;
        config.interfaces = new_config.interfaces;
        config.save()?;
        break;
    }
    println!(
        "Sucessfully saved edited config to {}.",
        &config.path().display()
    );
    Ok(())
}

async fn config_not_found(existing_path: Option<&Path>) -> Result<()> {
    let should_setup = prompt_confirmation(
        "Could not find an existing config path. Would you like to use cfdns setup?",
    ).into_diagnostic()?;
    if should_setup {
        crate::commands::setup(existing_path).await?;
        Ok(())
    } else {
        println!("Exiting...");
        Ok(())
    }
}

fn invalid_edit(e: &serde_yaml::Error) -> Result<bool, EditError> {
    println!("{}", "Edited configuration is invalid!".red());
    println!("{}", e);
    let should_retry = prompt_confirmation("Would you like to retry the edit?")?;
    Ok(should_retry)
}


#[derive(Debug, Error, Diagnostic)]
pub enum EditError {
    #[error("edit aborted")]
    Aborted,
    #[error("existing configuration not found")]
    ConfigNotFound(Option<PathBuf>),
    #[error("failed to load config for editing")]
    Config(
        #[from]
        #[diagnostic_source]
        ConfigError,
    ),
    #[error(transparent)]
    Prompt(InquireError),
}
impl From<InquireError> for EditError {
    fn from(value: InquireError) -> Self {
        match value {
            InquireError::OperationCanceled => EditError::Aborted,
            InquireError::OperationInterrupted => {
                println!(""); // To fix line formatting
                EditError::Aborted
            },
            others => EditError::Prompt(others)
        }
    }
}