Add a link to a similar project.

[gandi_dns_update.git] / src / main.rs

diff --git a/src/main.rs b/src/main.rs
index 1509a25..fa7584e 100644 (file)
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,19 +1,168 @@
-// API Reference: https://api.gandi.net/docs/livedns/
-// Some inspiration: https://github.com/rmarchant/gandi-ddns/blob/master/gandi_ddns.py
+/*
+ * API Reference: https://api.gandi.net/docs/livedns/
+ * Some similar implementations:
+ * - https://github.com/rmarchant/gandi-ddns/blob/master/gandi_ddns.py
+ * - https://github.com/brianhp2/gandi-automatic-dns
+ */
 
+#![cfg_attr(debug_assertions, allow(unused_variables, unused_imports, dead_code))]
 
-fn main() {
-    println!("Hello, world!");
+use std::{ fmt::format, fs::File, net::{ IpAddr, Ipv4Addr }, thread, time };
+use ron::{ de::from_reader, ser::to_writer };
+use serde::{ Deserialize, Serialize };
+use serde_json::Value;
+
+type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
+
+#[derive(Debug)]
+struct Error {
+    message: String
 }
 
-fn get_real_ip() {
+impl std::fmt::Display for Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&self.message)
+    }
+}
 
+impl std::error::Error for Error { }
+
+#[derive(Debug, Deserialize, Serialize)]
+struct Config {
+    delay_between_check: time::Duration,
+    api_key: String,
+    domains: Vec<String>,
 }
 
-fn get_current_record_ip() {
+impl Config {
+    fn default() -> Self {
+        Config { delay_between_check: time::Duration::from_secs(60), api_key: String::from(""), domains: Vec::new() }
+    }
 
+    fn read(file_path: &str) -> Result<Config> {
+        match File::open(file_path) {
+            Ok(file) => from_reader(file).map_err(|e| e.into()),
+            // The file doesn't exit -> create it with default values.
+            Err(_) => {
+                let file = File::create(file_path)?;
+                let default_config = Config::default();
+                to_writer(file, &default_config)?;
+                Ok(default_config)
+            }
+        }
+    }
 }
 
-fn update_record_ip() {
+const FILE_CONF: &str = "config.ron";
+
+fn main() -> Result<()> {
+    println!("GANDI DynDNS");
+
+    let config = Config::read(FILE_CONF)?;
+
+    println!("Configuration: {:?}", config);
+
+    loop {
+        let time_beginning_loop = time::Instant::now();
+
+        check_and_update_dns(&config.api_key);
+
+        let elapsed = time::Instant::now() - time_beginning_loop;
+
+        if elapsed < config.delay_between_check {
+            let to_wait = config.delay_between_check - elapsed;
+            thread::sleep(to_wait);
+        }
+
+    }
+}
+
+fn check_and_update_dns(api_key: &str) {
+    /*
+    */
+    //dbg!(get_real_ip());
+
+    get_current_record_ip(api_key);
+}
+
+fn get_real_ip() -> Result<Ipv4Addr> {
 
+    let url = "https://api.ipify.org";
+    let client = reqwest::blocking::Client::new();
+
+    match client.get(url).send() {
+        Ok(resp) =>
+            if resp.status().is_success() {
+                let content = resp.text().unwrap();
+                match content.parse::<IpAddr>() {
+                    Ok(IpAddr::V4(ip_v4)) => Ok(ip_v4),
+                    /*Err(_)*/ _ => Err(Box::new(Error { message: String::from("Can't parse IPv4 from ipify") }))
+                }
+                //println!("Content:\n{:?}", content);
+            } else {
+                //println!("Request unsuccessful:\n{:#?}", resp);
+                Err(Box::new(Error { message: format!("Request unsuccessful: {:#?}", resp) }))
+            },
+
+        Err(error) => {
+            //println!("Error during request: {:?}", error);
+            Err(Box::new(Error { message: format!("Error during request: {:?}", error) }))
+        }
+    }
+}
+
+fn request_livedns_gandi(api_key: &str, url_fragment: &str) -> Result<Value> {
+    let url = format!("https://api.gandi.net/v5/livedns/{}", url_fragment);
+    let client = reqwest::blocking::Client::new();
+
+    match client.get(&url).header("Authorization", format!("Apikey {}", api_key)).send() {
+        Ok(resp) =>
+            if resp.status().is_success() {
+                let content = resp.text().unwrap();
+                Ok(serde_json::from_str(&content).unwrap())
+            } else {
+                Err(Box::new(Error { message: format!("Request unsuccessful: {:#?}", resp) }))
+            },
+        Err(error) =>
+            Err(Box::new(Error { message: format!("Error during request: {:?}", error) }))
+    }
+}
+
+fn get_current_record_ip(api_key: &str) -> Result<Ipv4Addr> {
+
+    request_livedns_gandi(api_key, "domains/euphorik.ch/records/home/A")?; // TODO...
+        // .map()
+        //.map(|json_value| json_value["rrset_values"][0].as_str().unwrap())
+
+    Result::Err(Box::new(Error { message: String::new() }))
+
+
+    //let url = "https://api.gandi.net/v5/livedns/domains/euphorik.ch/records";
+    //let url = "https://api.gandi.net/v5/livedns/domains"; // ?sharing_id="
+    //let url = "https://api.gandi.net/v5/organization/organizations";
+    //let url = "https://api.gandi.net/v5/livedns/domains/euphorik.ch/records/home/A";
+
+    /*
+    let client = reqwest::blocking::Client::new();
+
+    match client.get(url).header("Authorization", format!("Apikey {}", api_key)).send() {
+        Ok(resp) =>
+            if resp.status().is_success() {
+                let content = resp.text().unwrap();
+
+                let json: Value = serde_json::from_str(&content).unwrap();
+                let prout = json["rrset_values"][0].as_str().unwrap();
+                println!("IP: {}", prout);
+
+                println!("Content:\n{}", serde_json::to_string_pretty(&json).unwrap());
+            } else {
+                println!("Request unsuccessful:\n{:#?}", resp);
+            },
+        Err(error) =>
+            println!("Error during request: {:?}", error)
+    }
+    */
+}
+
+fn update_record_ip() {
 }