Updated the client to update a record instead of creating a new record.

* Also cleaned up the methods to find and update records.
* Added functionality to create methods if no record already exists.

src/server/api.rs

@@ -1,5 +1,5 @@
 use std::io::Read;
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+use std::net::IpAddr;
 use std::str::FromStr;
 
 use actix_web::{AsyncResponder, FutureResponse, HttpMessage, HttpRequest, HttpResponse, Scope};
@@ -10,12 +10,25 @@ use cloudflare::{Cloudflare, zones};
 use futures::future::Future;
 
 use crate::config::model::Config;
-use crate::server::error::APIError;
+use crate::server::error::{APIError, Error};
 use crate::server::error::Result;
 use crate::server::middleware::api_auth::APIAuthRootAndZone;
 use crate::server::router::AppState;
 use crate::server::util;
 
+trait RecordType {
+    fn get_record_type(&self) -> zones::dns::RecordType;
+}
+
+impl RecordType for IpAddr {
+    fn get_record_type(&self) -> zones::dns::RecordType {
+        match &self {
+            IpAddr::V4(_) => zones::dns::RecordType::A,
+            IpAddr::V6(_) => zones::dns::RecordType::AAAA
+        }
+    }
+}
+
 pub fn route(scope: Scope<AppState>) -> Scope<AppState> {
     scope
         .resource("address", |r| r.method(Method::GET).f(get_request_address))
@@ -52,18 +65,55 @@ fn parse_remote_info(remote_info: &str) -> Result<IpAddr> {
     }
 }
 
-fn get_request_address(req: &HttpRequest<AppState>) -> HttpResponse {
+fn determine_request_address(req: &HttpRequest<AppState>) -> Result<Option<IpAddr>> {
     match req.connection_info().remote() {
         Some(remote_info) => match parse_remote_info(remote_info) {
-            Ok(addr) => HttpResponse::build(StatusCode::OK)
-                .content_type("text/plain")
-                .body(format!("{}", addr)),
+            Ok(addr) => Ok(Some(addr)),
             Err(e) => {
                 error!("{:?}", e);
-                HttpResponse::build(StatusCode::BAD_REQUEST).finish()
+                Err(Error::from(e))
             }
         }
-        None => HttpResponse::build(StatusCode::BAD_REQUEST).finish(),
+        None => Ok(None),
+    }
+}
+
+fn get_request_address(req: &HttpRequest<AppState>) -> HttpResponse {
+    match determine_request_address(&req) {
+        Ok(potential_addr) => match potential_addr {
+            Some(addr) => HttpResponse::build(StatusCode::OK)
+                .content_type("text/plain")
+                .body(format!("{}", addr)),
+            None => HttpResponse::build(StatusCode::BAD_REQUEST).finish()
+        },
+        Err(e) => {
+            error!("{:?}", e);
+            HttpResponse::build(StatusCode::BAD_REQUEST).finish()
+        }
+    }
+}
+
+fn find_dns_record(
+    cloudflare: &Cloudflare,
+    zone_id: &str,
+    record_type: zones::dns::RecordType,
+    record_name: &str,
+) -> Result<Option<zones::dns::DnsRecord>> {
+    match zones::dns::list_dns_of_type(cloudflare, &zone_id, record_type) {
+        Ok(dns_entries) => {
+            debug!("Looking for dns record: {}", record_name);
+            for dns_entry in dns_entries {
+                debug!("record {:?}", dns_entry);
+                if dns_entry.name == record_name {
+                    return Ok(Some(dns_entry));
+                }
+            }
+            Ok(None)
+        }
+        Err(e) => {
+            error!("{:?}", e);
+            Err(Error::from(e))
+        }
     }
 }
 
@@ -78,29 +128,25 @@ fn get_address(req: &HttpRequest<AppState>) -> HttpResponse {
         let root = root_match.unwrap();
         let zone = zone_match.unwrap();
         match util::get_domain_from_root(&root) {
-            Some(domain) => match zones::get_zoneid(cloudflare, &domain) {
-                Ok(zone_id) => match zones::dns::list_dns_of_type(cloudflare, &zone_id, zones::dns::RecordType::A) {
-                    Ok(dns_entries) => {
-                        let record_name = format!("{}.{}", &zone, &root);
-                        debug!("Looking for dns record: {}", record_name);
-                        for dns_entry in dns_entries {
-                            debug!("record {:?}", dns_entry);
-                            if dns_entry.name == record_name {
-                                return HttpResponse::build(StatusCode::OK)
-                                    .content_type("text/plain")
-                                    .body(format!("{}", dns_entry.content));
-                            }
-                        }
-                        HttpResponse::NotFound().into()
+            Some(domain) => {
+                let zone_id = match zones::get_zoneid(cloudflare, &domain) {
+                    Ok(zone_id) => zone_id,
+                    Err(e) => {
+                        error!("{:?}", e);
+                        return HttpResponse::BadRequest().into();
                     }
+                };
+                match find_dns_record(cloudflare, &zone_id, zones::dns::RecordType::A, &format!("{}.{}", &zone, &root)) {
+                    Ok(record) => match record {
+                        Some(dns_entry) => HttpResponse::build(StatusCode::OK)
+                            .content_type("text/plain")
+                            .body(format!("{}", dns_entry.content)),
+                        None => HttpResponse::NotFound().into()
+                    },
                     Err(e) => {
                         error!("{:?}", e);
                         HttpResponse::InternalServerError().into()
                     }
-                },
-                Err(e) => {
-                    error!("{:?}", e);
-                    HttpResponse::InternalServerError().into()
                 }
             },
             None => HttpResponse::BadRequest().into()
@@ -118,56 +164,65 @@ fn update_address_automatically(req: &HttpRequest<AppState>) -> HttpResponse {
     } else {
         let root = root_match.unwrap();
         let zone = zone_match.unwrap();
+        let request_address = match determine_request_address(&req) {
+            Ok(potential_addr) => match potential_addr {
+                Some(addr) => addr,
+                None => return HttpResponse::build(StatusCode::BAD_REQUEST).finish()
+            },
+            Err(e) => {
+                error!("{:?}", e);
+                return HttpResponse::build(StatusCode::BAD_REQUEST).finish();
+            }
+        };
+        let request_address_content = format!("{}", request_address);
+        let record_name = format!("{}.{}", &zone, &root);
         match util::get_domain_from_root(&root) {
-            Some(domain) => match zones::get_zoneid(cloudflare, &domain) {
-                Ok(zone_id) => match zones::dns::list_dns_of_type(cloudflare, &zone_id, zones::dns::RecordType::A) {
-                    Ok(dns_entries) => {
-                        let record_name = format!("{}.{}", &zone, &root);
-                        debug!("Looking for dns record: {}", record_name);
-                        for dns_entry in dns_entries {
-                            debug!("record {:?}", dns_entry);
-                            if dns_entry.name == record_name {
-                                return match req.connection_info().remote() {
-                                    Some(remote_info) => match parse_remote_info(remote_info) {
-                                        Ok(addr) => match addr {
-                                            IpAddr::V4(_) => match zones::dns::create_dns_entry(cloudflare, &zone_id, zones::dns::RecordType::A, &record_name, &format!("{}", addr)) {
-                                                Ok(result_record) => HttpResponse::build(StatusCode::OK)
-                                                    .content_type("text/plain")
-                                                    .body(format!("{}", result_record.content)),
-                                                Err(e) => {
-                                                    error!("{:?}", e);
-                                                    HttpResponse::InternalServerError().into()
-                                                }
-                                            },
-                                            IpAddr::V6(_) => match zones::dns::create_dns_entry(cloudflare, &zone_id, zones::dns::RecordType::AAAA, &record_name, &format!("{}", addr)) {
-                                                Ok(result_record) => HttpResponse::build(StatusCode::OK)
-                                                    .content_type("text/plain")
-                                                    .body(format!("{}", result_record.content)),
-                                                Err(e) => {
-                                                    error!("{:?}", e);
-                                                    HttpResponse::InternalServerError().into()
-                                                }
-                                            }
-                                        },
-                                        Err(e) => {
-                                            error!("{:?}", e);
-                                            HttpResponse::InternalServerError().into()
-                                        }
-                                    },
-                                    None => HttpResponse::BadRequest().into()
-                                };
+            Some(domain) => {
+                let zone_id = match zones::get_zoneid(cloudflare, &domain) {
+                    Ok(zone_id) => zone_id,
+                    Err(e) => {
+                        error!("{:?}", e);
+                        return HttpResponse::BadRequest().into();
+                    }
+                };
+                match find_dns_record(cloudflare, &zone_id, request_address.get_record_type(), &record_name) {
+                    Ok(record) => match record {
+                        Some(dns_entry) => {
+                            match zones::dns::update_dns_entry(
+                                cloudflare,
+                                &dns_entry.zone_id,
+                                &dns_entry.id,
+                                request_address.get_record_type(),
+                                &dns_entry.name,
+                                &request_address_content) {
+                                Ok(result_record) => HttpResponse::build(StatusCode::OK)
+                                    .content_type("text/plain")
+                                    .body(format!("{}", result_record.content)),
+                                Err(e) => {
+                                    error!("{:?}", e);
+                                    HttpResponse::InternalServerError().into()
+                                }
                             }
                         }
-                        HttpResponse::BadRequest().into()
-                    }
+                        None => match zones::dns::create_dns_entry(
+                            cloudflare,
+                            &zone_id,
+                            request_address.get_record_type(),
+                            &record_name,
+                            &request_address_content) {
+                            Ok(result_record) => HttpResponse::build(StatusCode::OK)
+                                .content_type("text/plain")
+                                .body(format!("{}", result_record.content)),
+                            Err(e) => {
+                                error!("{:?}", e);
+                                HttpResponse::InternalServerError().into()
+                            }
+                        }
+                    },
                     Err(e) => {
                         error!("{:?}", e);
                         HttpResponse::InternalServerError().into()
                     }
-                },
-                Err(e) => {
-                    error!("{:?}", e);
-                    HttpResponse::InternalServerError().into()
                 }
             },
             None => HttpResponse::BadRequest().into()