WIP

Author: Kitt3120

src/cli.rs

@@ -10,5 +10,5 @@ pub trait ExecutableCommand<'input> {
     type I;
     type R;
 
-    fn execute(&self, input: &'input Self::I) -> impl Future<Output = Self::R> + Send;
+    fn execute(&self, input: &'input Self::I) -> impl Future<Output = Self::R>;
 }

src/cli/command.rs

@@ -10,7 +10,7 @@ use crate::{
 };
 
 #[derive(Debug, ClapSubcommand)]
-#[command(version, about, long_about = None, propagate_version = true)]
+#[command(version, about, long_about = None)]
 pub enum Subcommand<'a> {
     Auto(auto::Command<'a>),
     Get(get::Command<'a>),

src/cli/get.rs

@@ -7,7 +7,7 @@ use crate::{
     Config,
     cli::ExecutableCommand,
     config::provider::Provider as ProviderConfig,
-    provider::{Provider, nitrado::NitradoProvider},
+    provider::{GetAllRecordsInput, GetRecordsInput, Provider, nitrado::NitradoProvider},
 };
 
 #[derive(Debug)]
@@ -20,21 +20,24 @@ pub struct Input<'config> {
 pub enum Error {
     #[error("The given provider is not configured: {0}")]
     ProviderNotConfigured(String),
+
+    #[error("Provider error: {0}")]
+    ProviderError(#[from] anyhow::Error),
 }
 
 //TODO: Fix order of usage message (provider should come first)
 #[derive(Debug, Args)]
 #[group(required = true, multiple = false)]
-pub struct DomainArgs {
-    /// Domains to get records for
-    domains: Vec<String>,
+pub struct SubdomainArgs {
+    /// Subdomains to get records for
+    subdomains: Vec<String>,
 
     /// Get all records
     #[clap(short, long, default_value = "false")]
     pub all: bool,
 }
 
-/// Update providers as defined in the configuration file
+/// Get one or more DNS records from a provider
 #[derive(Debug, Parser)]
 #[command(version, about, long_about = None, propagate_version = true)]
 pub struct Command<'command> {
@@ -44,10 +47,14 @@ pub struct Command<'command> {
     /// Name of the provider to get records from
     provider: String,
 
+    /// Domain to get records for
+    domain: String,
+
     #[command(flatten)]
-    domain_args: DomainArgs,
+    subdomain_args: SubdomainArgs,
 }
 
+//TODO: Move
 fn get_provider<'config>(
     name: &str,
     config: &'config Config,
@@ -73,13 +80,42 @@ impl<'command> ExecutableCommand<'command> for Command<'command> {
         let config = input.config;
         let provider_name = self.provider.as_str();
 
-        let _provider = match get_provider(provider_name, config) {
+        let provider = match get_provider(provider_name, config) {
             Some(p) => p,
             None => return Err(Error::ProviderNotConfigured(provider_name.to_string())),
         };
 
-        let _reqwest = reqwest::Client::new();
+        let reqwest = reqwest::Client::new();
+
+        let results = if self.subdomain_args.all {
+            let input = GetAllRecordsInput {
+                domain: self.domain.as_str(),
+            };
+
+            provider.get_all_records(reqwest, &input).await
+        } else {
+            let input = GetRecordsInput {
+                domain: self.domain.as_str(),
+                subdomains: self
+                    .subdomain_args
+                    .subdomains
+                    .iter()
+                    .map(|s| s.as_str())
+                    .collect(),
+            };
+
+            provider.get_records(reqwest, &input).await
+        };
+
+        let records = match results {
+            Err(e) => {
+                eprintln!("Error: {}", e);
+                return Err(e.into());
+            }
+            Ok(records) => records,
+        };
 
+        println!("Records: {:#?}", records);
         Ok(())
     }
 }

src/provider.rs

@@ -7,16 +7,36 @@ pub mod nitrado;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Feature {
-    GetRecord,
     GetRecords,
+    GetAllRecords,
     AddRecord,
     UpdateRecord,
     DeleteRecord,
 }
 
-pub struct GetRecordInput {}
-pub struct GetRecordsInput {
-    pub domain: String,
+pub struct GetRecordsInput<'input> {
+    pub domain: &'input str,
+    pub subdomains: Vec<&'input str>,
+}
+
+pub struct GetAllRecordsInput<'input> {
+    pub domain: &'input str,
+}
+
+impl<'input> From<GetRecordsInput<'input>> for GetAllRecordsInput<'input> {
+    fn from(input: GetRecordsInput<'input>) -> Self {
+        GetAllRecordsInput {
+            domain: input.domain,
+        }
+    }
+}
+
+impl<'input> From<&'input GetRecordsInput<'input>> for GetAllRecordsInput<'input> {
+    fn from(input: &'input GetRecordsInput<'input>) -> Self {
+        GetAllRecordsInput {
+            domain: input.domain,
+        }
+    }
 }
 
 #[async_trait]
@@ -32,7 +52,13 @@ pub trait Provider {
         reqwest: reqwest::Client,
         input: &GetRecordsInput,
     ) -> Result<Vec<Record>>;
-    async fn get_all_records(&self, reqwest: reqwest::Client) -> Result<Vec<Record>>;
+
+    async fn get_all_records(
+        &self,
+        reqwest: reqwest::Client,
+        input: &GetAllRecordsInput,
+    ) -> Result<Vec<Record>>;
+
     async fn add_record(&self, reqwest: reqwest::Client, record: &Record) -> Result<()>;
     async fn update_record(&self, reqwest: reqwest::Client, record: &Record) -> Result<()>;
     async fn delete_record(&self, reqwest: reqwest::Client, record: &Record) -> Result<()>;

src/provider/nitrado.rs

@@ -1,110 +1,19 @@
-use std::{
-    net::{Ipv4Addr, Ipv6Addr},
-    str::FromStr,
-};
-
 use anyhow::Result;
 use async_trait::async_trait;
-use lum_libs::{
-    serde::{Deserialize, Serialize},
-    serde_json,
-};
+use lum_libs::serde_json;
 use reqwest::header::HeaderMap;
 use thiserror::Error;
 
 use crate::{
-    config::dns::{AutomaticRecordConfig, RecordConfig, ResolveType},
-    provider::{self, Feature, Provider},
-    types::dns::{self, MxRecord, Record, RecordValue},
+    provider::{Feature, GetAllRecordsInput, GetRecordsInput, Provider},
+    types::dns::{self},
 };
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(crate = "lum_libs::serde")]
-pub struct Config {
-    pub name: String,
-    pub api_key: String,
-    pub api_base_url: String,
-}
+pub mod config;
+pub mod model;
 
-impl Default for Config {
-    fn default() -> Self {
-        Config {
-            name: "Nitrado1".to_string(),
-            api_key: "your_api_key".to_string(),
-            api_base_url: "https://api.nitrado.net".to_string(),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(crate = "lum_libs::serde")]
-pub struct DomainConfig {
-    pub domain: String,
-    pub records: Vec<RecordConfig>,
-}
-
-#[derive(Debug, Clone, Serialize, Deserialize)]
-#[serde(crate = "lum_libs::serde")]
-pub struct DnsConfig {
-    pub provider_name: String,
-    pub domains: Vec<DomainConfig>,
-}
-
-impl Default for DnsConfig {
-    fn default() -> Self {
-        DnsConfig {
-            provider_name: "Nitrado1".to_string(),
-            domains: vec![DomainConfig {
-                domain: "example.com".to_string(),
-                records: vec![
-                    RecordConfig::Manual(dns::Record {
-                        domain: "ipv4".to_string(),
-                        value: RecordValue::A(Ipv4Addr::from_str("127.0.0.1").unwrap()),
-                        ttl: Some(3600),
-                    }),
-                    RecordConfig::Manual(dns::Record {
-                        domain: "ipv6".to_string(),
-                        value: RecordValue::AAAA(Ipv6Addr::from_str("::1").unwrap()),
-                        ttl: Some(3600),
-                    }),
-                    RecordConfig::Manual(dns::Record {
-                        domain: "forward".to_string(),
-                        value: RecordValue::CNAME("example.com".to_string()),
-                        ttl: Some(3600),
-                    }),
-                    RecordConfig::Manual(dns::Record {
-                        domain: "@".to_string(),
-                        value: RecordValue::MX(MxRecord {
-                            priority: 10,
-                            target: "mail.example.com".to_string(),
-                        }),
-                        ttl: Some(3600),
-                    }),
-                    RecordConfig::Manual(dns::Record {
-                        domain: "@".to_string(),
-                        value: RecordValue::TXT("v=spf1 include:example.com ~all".to_string()),
-                        ttl: Some(3600),
-                    }),
-                    RecordConfig::Manual(dns::Record {
-                        domain: "@".to_string(),
-                        value: RecordValue::Custom("RecordType".to_string(), "Value".to_string()),
-                        ttl: Some(3600),
-                    }),
-                    RecordConfig::Automatic(AutomaticRecordConfig {
-                        domain: "auto-ipv4".to_string(),
-                        ttl: Some(300),
-                        resolve_type: ResolveType::IPv4,
-                    }),
-                    RecordConfig::Automatic(AutomaticRecordConfig {
-                        domain: "auto-ipv6".to_string(),
-                        ttl: Some(300),
-                        resolve_type: ResolveType::IPv6,
-                    }),
-                ],
-            }],
-        }
-    }
-}
+pub use config::{Config, DnsConfig, DomainConfig};
+pub use model::{GetRecordsResponse, Record, RecordMode, TryFromRecordError};
 
 pub struct NitradoProvider<'provider_config> {
     pub provider_config: &'provider_config Config,
@@ -136,8 +45,8 @@ impl Provider for NitradoProvider<'_> {
 
     fn get_supported_features(&self) -> Vec<Feature> {
         vec![
-            Feature::GetRecord,
             Feature::GetRecords,
+            Feature::GetAllRecords,
             Feature::AddRecord,
             Feature::UpdateRecord,
             Feature::DeleteRecord,
@@ -146,8 +55,25 @@ impl Provider for NitradoProvider<'_> {
     async fn get_records(
         &self,
         reqwest: reqwest::Client,
-        input: &provider::GetRecordsInput,
-    ) -> Result<Vec<Record>> {
+        input: &GetRecordsInput,
+    ) -> Result<Vec<dns::Record>> {
+        let get_all_records_input = GetAllRecordsInput::from(input);
+        let records = self
+            .get_all_records(reqwest, &get_all_records_input)
+            .await?;
+        let records = records
+            .into_iter()
+            .filter(|record| input.subdomains.contains(&record.domain.as_str()))
+            .collect();
+
+        Ok(records)
+    }
+
+    async fn get_all_records(
+        &self,
+        reqwest: reqwest::Client,
+        input: &GetAllRecordsInput,
+    ) -> Result<Vec<dns::Record>> {
         let mut headers = HeaderMap::new();
         headers.insert(
             "Authorization",
@@ -168,23 +94,21 @@ impl Provider for NitradoProvider<'_> {
         }
 
         let text = response.text().await?;
-        let json = serde_json::from_str(&text)?;
-        Ok(json)
-    }
+        let response: GetRecordsResponse = serde_json::from_str(&text)?;
+        let records: Vec<dns::Record> = response.try_into()?;
 
-    async fn get_all_records(&self, _reqwest: reqwest::Client) -> Result<Vec<Record>> {
-        unimplemented!()
+        Ok(records)
     }
 
-    async fn add_record(&self, _reqwest: reqwest::Client, _input: &Record) -> Result<()> {
+    async fn add_record(&self, _reqwest: reqwest::Client, _input: &dns::Record) -> Result<()> {
         unimplemented!()
     }
 
-    async fn update_record(&self, _reqwest: reqwest::Client, _input: &Record) -> Result<()> {
+    async fn update_record(&self, _reqwest: reqwest::Client, _input: &dns::Record) -> Result<()> {
         unimplemented!()
     }
 
-    async fn delete_record(&self, _reqwest: reqwest::Client, _input: &Record) -> Result<()> {
+    async fn delete_record(&self, _reqwest: reqwest::Client, _input: &dns::Record) -> Result<()> {
         unimplemented!()
     }
 }