nomilo/src/dns/mod.rs

pub mod rdata;
pub mod record;
pub mod dns_driver;

use std::sync::Arc;

use async_trait::async_trait;

pub type BoxedZoneDriver = Arc<dyn ZoneDriver>;
pub enum DnsDriverError {
    ConnectionError { reason: Box<dyn std::error::Error> },
    OperationError { reason: Box<dyn std::error::Error> },
    ServerError { rcode: String, name: String, qtype: String },
    ZoneNotFound { name: String },
}

#[async_trait]
pub trait ZoneDriver: Send + Sync {
    // get_zones
    // add_zone
    // delete_zone
    async fn zone_exists(&self, zone: &str) -> Result<(), DnsDriverError>;
}

#[async_trait]
pub trait RecordDriver: Send + Sync {
    async fn get_records(&self, zone: &str) -> Result<Vec<record::Record>, DnsDriverError>;
    async fn add_records(&self, zone: &str, new_records: &[record::DnsRecordImpl]) -> Result<(), DnsDriverError>;
    //async fn update_records(&mut self, zone: dns::Name, class: dns::DNSClass, old_records: Vec<dns::Record>, new_records: Vec<dns::Record>) -> ConnectorResult<()>;
    //async fn delete_records(&mut self, zone: dns::Name, class: dns::DNSClass, records: Vec<dns::Record>) -> ConnectorResult<()>;

}

/*
pub mod client;
pub mod dns_connector;
pub mod connector;

// Reexport trust dns types for convenience
pub use trust_dns_client::rr::rdata::{
    DNSSECRData, caa, sshfp, mx, null, soa, srv, txt
};
pub use trust_dns_client::rr::{
    RData, DNSClass, Record
};
pub use trust_dns_proto::rr::Name;
pub use trust_dns_proto::rr::dnssec::rdata::tsig::TsigAlgorithm;

// Reexport module types
pub use connector::{RecordConnector, ZoneConnector, ConnectorError};
pub use dns_connector::{DnsConnectorClient, DnsConnectorError};
pub use client::DnsClient;


use rocket::{Request, State, http::Status, request::{FromRequest, Outcome}};
use rocket::outcome::try_outcome;

use crate::config::Config;


#[rocket::async_trait]
impl<'r> FromRequest<'r> for Box<dyn RecordConnector> {
    type Error = ();
    async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Self::Error> {
        let config = try_outcome!(request.guard::<&State<Config>>().await);
        match DnsClient::from_config(&config.dns).await {
            Err(e) => {
                error!("Failed to connect to DNS server: {}", e);
                Outcome::Failure((Status::InternalServerError, ()))
            },
            Ok(c) => Outcome::Success(Box::new(DnsConnectorClient::new(c)))
        }
    }
}

#[rocket::async_trait]
impl<'r> FromRequest<'r> for Box<dyn ZoneConnector> {
    type Error = ();
    async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Self::Error> {
        let config = try_outcome!(request.guard::<&State<Config>>().await);
        match DnsClient::from_config(&config.dns).await {
            Err(e) => {
                error!("Failed to connect to DNS server: {}", e);
                Outcome::Failure((Status::InternalServerError, ()))
            },
            Ok(c) => Outcome::Success(Box::new(DnsConnectorClient::new(c)))
        }
    }
}
*/