Merge pull request 'Fig regression of peach-dyndns-updater' (#63) from fix-regression into main

Reviewed-on: #63

.gitignore

@@ -2,3 +2,4 @@
 target
 *peachdeploy.sh
 *vpsdeploy.sh
+*bindeploy.sh

peach-config/src/setup_peach.rs

@@ -68,6 +68,7 @@ pub fn setup_peach(
         "libssl-dev",
         "nginx",
         "wget",
+        "dnsutils",
         "-y",
     ])?;
 

peach-dyndns-updater/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "peach-dyndns-updater"
-version = "0.1.6"
+version = "0.1.8"
 authors = ["Max Fowler <mfowler@commoninternet.net>"]
 edition = "2018"
 description = "Sytemd timer which keeps a dynamic dns subdomain up to date with the latest device IP using nsupdate."

peach-dyndns-updater/src/main.rs

@@ -1,6 +1,5 @@
+use log::info;
 use peach_lib::dyndns_client::dyndns_update_ip;
-use log::{info};
-
 
 fn main() {
     // initalize the logger
@@ -9,4 +8,4 @@ fn main() {
     info!("Running peach-dyndns-updater");
     let result = dyndns_update_ip();
     info!("result: {:?}", result);
-}
+}

peach-lib/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "peach-lib"
-version = "1.3.1"
+version = "1.3.2"
 authors = ["Andrew Reid <glyph@mycelial.technology>"]
 edition = "2018"
 

peach-lib/src/config_manager.rs

@@ -17,6 +17,10 @@ pub const YAML_PATH: &str = "/var/lib/peachcloud/config.yml";
 // lock file (used to avoid race conditions during config reading & writing)
 pub const LOCK_FILE_PATH: &str = "/var/lib/peachcloud/config.lock";
 
+// default values
+pub const DEFAULT_DYN_SERVER_ADDRESS: &str = "http://dynserver.dyn.peachcloud.org";
+pub const DEFAULT_DYN_NAMESERVER: &str = "ns.peachcloud.org";
+
 // we make use of Serde default values in order to make PeachCloud
 // robust and keep running even with a not fully complete config.yml
 // main type which represents all peachcloud configurations
@@ -29,6 +33,10 @@ pub struct PeachConfig {
     #[serde(default)]
     pub dyn_dns_server_address: String,
     #[serde(default)]
+    pub dyn_use_custom_server: bool,
+    #[serde(default)]
+    pub dyn_nameserver: String,
+    #[serde(default)]
     pub dyn_tsig_key_path: String,
     #[serde(default)] // default is false
     pub dyn_enabled: bool,
@@ -63,20 +71,19 @@ fn save_peach_config(peach_config: PeachConfig) -> Result<PeachConfig, PeachErro
 pub fn load_peach_config() -> Result<PeachConfig, PeachError> {
     let peach_config_exists = std::path::Path::new(YAML_PATH).exists();
 
-    let peach_config: PeachConfig;
+    let peach_config: PeachConfig = if !peach_config_exists {
-
+        PeachConfig {
-    // if this is the first time loading peach_config, we can create a default here
-    if !peach_config_exists {
-        peach_config = PeachConfig {
             external_domain: "".to_string(),
             dyn_domain: "".to_string(),
-            dyn_dns_server_address: "".to_string(),
+            dyn_dns_server_address: DEFAULT_DYN_SERVER_ADDRESS.to_string(),
+            dyn_use_custom_server: false,
+            dyn_nameserver: DEFAULT_DYN_NAMESERVER.to_string(),
             dyn_tsig_key_path: "".to_string(),
             dyn_enabled: false,
             ssb_admin_ids: Vec::new(),
             admin_password_hash: "".to_string(),
             temporary_password_hash: "".to_string(),
-        };
+        }
     }
     // otherwise we load peach config from disk
     else {
@@ -84,8 +91,8 @@ pub fn load_peach_config() -> Result<PeachConfig, PeachError> {
             source,
             path: YAML_PATH.to_string(),
         })?;
-        peach_config = serde_yaml::from_str(&contents)?;
+        serde_yaml::from_str(&contents)?
-    }
+    };
 
     Ok(peach_config)
 }
@@ -122,6 +129,18 @@ pub fn get_peachcloud_domain() -> Result<Option<String>, PeachError> {
     }
 }
 
+pub fn get_dyndns_server_address() -> Result<String, PeachError> {
+    let peach_config = load_peach_config()?;
+    // if the user is using a custom dyn server then load the address from the config
+    if peach_config.dyn_use_custom_server {
+        Ok(peach_config.dyn_dns_server_address)
+    }
+    // otherwise hardcode the address
+    else {
+        Ok(DEFAULT_DYN_SERVER_ADDRESS.to_string())
+    }
+}
+
 pub fn set_dyndns_enabled_value(enabled_value: bool) -> Result<PeachConfig, PeachError> {
     let mut peach_config = load_peach_config()?;
     peach_config.dyn_enabled = enabled_value;

peach-lib/src/dyndns_client.rs

@@ -9,13 +9,8 @@
 //!
 //! The domain for dyndns updates is stored in /var/lib/peachcloud/config.yml
 //! The tsig key for authenticating the updates is stored in /var/lib/peachcloud/peach-dyndns/tsig.key
-use std::{
+use std::ffi::OsStr;
-    fs,
+use std::{fs, fs::OpenOptions, io::Write, process::Command, str::FromStr};
-    fs::OpenOptions,
-    io::Write,
-    process::{Command, Stdio},
-    str::FromStr,
-};
 
 use chrono::prelude::*;
 use jsonrpc_client_core::{expand_params, jsonrpc_client};
@@ -23,13 +18,10 @@ use jsonrpc_client_http::HttpTransport;
 use log::{debug, info};
 use regex::Regex;
 
-use crate::{
+use crate::config_manager::get_dyndns_server_address;
-    config_manager::{load_peach_config, set_peach_dyndns_config},
+use crate::{config_manager, error::PeachError};
-    error::PeachError,
-};
 
 /// constants for dyndns configuration
-pub const PEACH_DYNDNS_URL: &str = "http://dynserver.dyn.peachcloud.org";
 pub const TSIG_KEY_PATH: &str = "/var/lib/peachcloud/peach-dyndns/tsig.key";
 pub const PEACH_DYNDNS_CONFIG_PATH: &str = "/var/lib/peachcloud/peach-dyndns";
 pub const DYNDNS_LOG_PATH: &str = "/var/lib/peachcloud/peach-dyndns/latest_result.log";
@@ -62,9 +54,10 @@ pub fn save_dyndns_key(key: &str) -> Result<(), PeachError> {
 pub fn register_domain(domain: &str) -> std::result::Result<String, PeachError> {
     debug!("Creating HTTP transport for dyndns client.");
     let transport = HttpTransport::new().standalone()?;
-    let http_server = PEACH_DYNDNS_URL;
+    let http_server = get_dyndns_server_address()?;
-    debug!("Creating HTTP transport handle on {}.", http_server);
+    info!("Using dyndns http server address: {:?}", http_server);
-    let transport_handle = transport.handle(http_server)?;
+    debug!("Creating HTTP transport handle on {}.", &http_server);
+    let transport_handle = transport.handle(&http_server)?;
     info!("Creating client for peach-dyndns service.");
     let mut client = PeachDynDnsClient::new(transport_handle);
 
@@ -73,7 +66,8 @@ pub fn register_domain(domain: &str) -> std::result::Result<String, PeachError>
     // save new TSIG key
     save_dyndns_key(&key)?;
     // save new configuration values
-    let set_config_result = set_peach_dyndns_config(domain, PEACH_DYNDNS_URL, TSIG_KEY_PATH, true);
+    let set_config_result =
+        config_manager::set_peach_dyndns_config(domain, &http_server, TSIG_KEY_PATH, true);
     match set_config_result {
         Ok(_) => {
             let response = "success".to_string();
@@ -87,9 +81,9 @@ pub fn register_domain(domain: &str) -> std::result::Result<String, PeachError>
 pub fn is_domain_available(domain: &str) -> std::result::Result<bool, PeachError> {
     debug!("Creating HTTP transport for dyndns client.");
     let transport = HttpTransport::new().standalone()?;
-    let http_server = PEACH_DYNDNS_URL;
+    let http_server = get_dyndns_server_address()?;
-    debug!("Creating HTTP transport handle on {}.", http_server);
+    debug!("Creating HTTP transport handle on {}.", &http_server);
-    let transport_handle = transport.handle(http_server)?;
+    let transport_handle = transport.handle(&http_server)?;
     info!("Creating client for peach_network service.");
     let mut client = PeachDynDnsClient::new(transport_handle);
 
@@ -113,31 +107,31 @@ fn get_public_ip_address() -> Result<String, PeachError> {
 /// Reads dyndns configurations from config.yml
 /// and then uses nsupdate to update the IP address for the configured domain
 pub fn dyndns_update_ip() -> Result<bool, PeachError> {
-    info!("Running dyndns_update_ip");
+    let peach_config = config_manager::load_peach_config()?;
-    let peach_config = load_peach_config()?;
     info!(
         "Using config:
     dyn_tsig_key_path: {:?}
     dyn_domain: {:?}
     dyn_dns_server_address: {:?}
     dyn_enabled: {:?}
+    dyn_nameserver: {:?}
     ",
         peach_config.dyn_tsig_key_path,
         peach_config.dyn_domain,
         peach_config.dyn_dns_server_address,
         peach_config.dyn_enabled,
+        peach_config.dyn_nameserver,
     );
     if !peach_config.dyn_enabled {
         info!("dyndns is not enabled, not updating");
         Ok(false)
     } else {
         // call nsupdate passing appropriate configs
-        let mut nsupdate_command = Command::new("/usr/bin/nsupdate")
+        let mut nsupdate_command = Command::new("/usr/bin/nsupdate");
+        nsupdate_command
             .arg("-k")
             .arg(&peach_config.dyn_tsig_key_path)
-            .arg("-v")
+            .arg("-v");
-            .stdin(Stdio::piped())
-            .spawn()?;
         // pass nsupdate commands via stdin
         let public_ip_address = get_public_ip_address()?;
         info!("found public ip address: {}", public_ip_address);
@@ -148,20 +142,20 @@ pub fn dyndns_update_ip() -> Result<bool, PeachError> {
         update delete {DOMAIN} A
         update add {DOMAIN} 30 A {PUBLIC_IP_ADDRESS}
         send",
-            NAMESERVER = "ns.peachcloud.org",
+            NAMESERVER = peach_config.dyn_nameserver,
             ZONE = peach_config.dyn_domain,
             DOMAIN = peach_config.dyn_domain,
             PUBLIC_IP_ADDRESS = public_ip_address,
         );
-        let mut nsupdate_stdin = nsupdate_command.stdin.take().ok_or(PeachError::NsUpdate {
+        info!("ns_commands: {:?}", ns_commands);
-            msg: "unable to capture stdin handle for `nsupdate` command".to_string(),
+        info!("creating nsupdate temp file");
-        })?;
+        let temp_file_path = "/var/lib/peachcloud/nsupdate.sh";
-        write!(nsupdate_stdin, "{}", ns_commands).map_err(|source| PeachError::Write {
+        // write ns_commands to temp_file
-            source,
+        fs::write(temp_file_path, ns_commands)?;
-            path: peach_config.dyn_tsig_key_path.to_string(),
+        nsupdate_command.arg(temp_file_path);
-        })?;
+        let nsupdate_output = nsupdate_command.output()?;
-        let nsupdate_output = nsupdate_command.wait_with_output()?;
+        let args: Vec<&OsStr> = nsupdate_command.get_args().collect();
-        info!("nsupdate output: {:?}", nsupdate_output);
+        info!("nsupdate command: {:?}", args);
         // We only return a successful result if nsupdate was successful
         if nsupdate_output.status.success() {
             info!("nsupdate succeeded, returning ok");
@@ -204,7 +198,7 @@ pub fn get_num_seconds_since_successful_dns_update() -> Result<Option<i64>, Peac
         })?;
         // replace newline if found
         // TODO: maybe we can use `.trim()` instead
-        let contents = contents.replace("\n", "");
+        let contents = contents.replace('\n', "");
         // TODO: consider adding additional context?
         let time_ran_dt = DateTime::parse_from_rfc3339(&contents).map_err(|source| {
             PeachError::ParseDateTime {
@@ -223,20 +217,15 @@ pub fn get_num_seconds_since_successful_dns_update() -> Result<Option<i64>, Peac
 /// and has successfully run recently (in the last six minutes)
 pub fn is_dns_updater_online() -> Result<bool, PeachError> {
     // first check if it is enabled in peach-config
-    let peach_config = load_peach_config()?;
+    let peach_config = config_manager::load_peach_config()?;
     let is_enabled = peach_config.dyn_enabled;
     // then check if it has successfully run within the last 6 minutes (60*6 seconds)
     let num_seconds_since_successful_update = get_num_seconds_since_successful_dns_update()?;
-    let ran_recently: bool;
+    let ran_recently: bool = match num_seconds_since_successful_update {
-    match num_seconds_since_successful_update {
+        Some(seconds) => seconds < (60 * 6),
-        Some(seconds) => {
-            ran_recently = seconds < (60 * 6);
-        }
         // if the value is None, then the last time it ran successfully is unknown
-        None => {
+        None => false,
-            ran_recently = false;
+    };
-        }
-    }
     // debug log
     info!("is_dyndns_enabled: {:?}", is_enabled);
     info!("dyndns_ran_recently: {:?}", ran_recently);
@@ -258,11 +247,10 @@ pub fn get_dyndns_subdomain(dyndns_full_domain: &str) -> Option<String> {
 }
 
 // helper function which checks if a dyndns domain is new
-pub fn check_is_new_dyndns_domain(dyndns_full_domain: &str) -> bool {
+pub fn check_is_new_dyndns_domain(dyndns_full_domain: &str) -> Result<bool, PeachError> {
-    // TODO: return `Result<bool, PeachError>` and replace `unwrap` with `?` operator
+    let peach_config = config_manager::load_peach_config()?;
-    let peach_config = load_peach_config().unwrap();
     let previous_dyndns_domain = peach_config.dyn_domain;
-    dyndns_full_domain != previous_dyndns_domain
+    Ok(dyndns_full_domain != previous_dyndns_domain)
 }
 
 jsonrpc_client!(pub struct PeachDynDnsClient {

peach-web/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "peach-web"
-version = "0.4.15"
+version = "0.4.17"
 authors = ["Andrew Reid <gnomad@cryptolab.net>"]
 edition = "2018"
 description = "peach-web is a web application which provides a web interface for monitoring and interacting with the PeachCloud device. This allows administration of the single-board computer (ie. Raspberry Pi) running PeachCloud, as well as the ssb-server and related plugins."

peach-web/README.md

@@ -97,6 +97,20 @@ Remove configuration files (not removed with `apt-get remove`):
 
 `peach-web` is built on the Rocket webserver and Tera templating engine. It presents a web interface for interacting with the device. HTML is rendered server-side. Request handlers call JSON-RPC microservices and serve HTML and assets. A JSON API is exposed for remote calls and dynamic client-side content updates (via plain JavaScript following unobstructive design principles). Each Tera template is passed a context object. In the case of Rust, this object is a `struct` and must implement `Serialize`. The fields of the context object are available in the context of the template to be rendered.
 
+### Configuration 
+
+Configuration variables are stored in /var/lib/peachcloud/config.yml. 
+Peach-web also updates this file when changes are made to configurations via
+the web interface. peach-web has no database, so all configurations are stored in this file. 
+
+#### Dynamic DNS Configuration 
+
+Most users will want to use the default PeachCloud dynamic dns server. 
+If the config dyn_use_custom_server=false, then default values will be used. 
+If the config dyn_use_custom_server=true, then a value must also be set for dyn_dns_server_address (e.g.  "http://peachdynserver.commoninternet.net").
+This value is the URL of the instance of peach-dyndns-server that requests will be sent to for domain registration. 
+Using a custom value can here can be useful for testing. 
+
 ### Licensing
 
 AGPL-3.0

peach-web/src/routes/settings/dns.rs

@@ -40,7 +40,7 @@ pub fn save_dns_configuration(dns_form: DnsForm) -> Result<(), PeachWebError> {
     if dns_form.enable_dyndns {
         let full_dynamic_domain = get_full_dynamic_domain(&dns_form.dynamic_domain);
         // check if this is a new domain or if its already registered
-        let is_new_domain = check_is_new_dyndns_domain(&full_dynamic_domain);
+        let is_new_domain = check_is_new_dyndns_domain(&full_dynamic_domain)?;
         if is_new_domain {
             match dyndns_client::register_domain(&full_dynamic_domain) {
                 Ok(_) => {