WIP: initial migration to trust-dns 0.19

Cargo.toml

@@ -29,22 +29,23 @@ serde = "1.0"
 serde_derive = "1.0"
 serde_json = "1.0"
 url_serde = { version = "0.2", default-features = false }
-base64 = "0.11"
+base64 = "0.12"
 regex = "1.3"
 r2d2 = "0.8"
-r2d2_redis = "0.11"
-redis = "0.12"
+r2d2_redis = "0.13"
+redis = "0.16"
 rocket = { version = "0.4", default-features = false }
 rocket_contrib = { version = "0.4", features = ["json"], default-features = false }
-trust-dns = { version = "0.13", default-features = false }
-trust-dns-server = { version = "0.13", default-features = false }
+trust-dns-proto = { version = "*", default-features = false, features = ["tokio-runtime", "dnssec-ring", "serde"]}
+trust-dns-server = { version = "*", default-features = false, features = ["dns-over-https-rustls", "dns-over-rustls", "dnssec-ring"] }
 rand = "0.7"
 farmhash = "1.1"
-http_req = { version = "0.5", features = ["rust-tls"], default-features = false }
+http_req = { version = "0.6", features = ["rust-tls"], default-features = false }
 maxminddb = "0.13"
 tempfile = "3.1"
 flate2 = "1.0"
 tar = "0.4"
+tokio = "0.2"
 
 [profile.dev]
 opt-level = 0

src/dns/code.rs

@@ -4,7 +4,7 @@
 // Copyright: 2019, Valerian Saliou <[email protected]>
 // License: Mozilla Public License v2.0 (MPL v2.0)
 
-use trust_dns::op::ResponseCode;
+use trust_dns_proto::op::ResponseCode;
 
 #[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize)]
 pub enum CodeName {

src/dns/handler.rs

@@ -9,11 +9,15 @@ use rand::thread_rng;
 use std::collections::HashMap;
 use std::net::IpAddr;
 use std::sync::RwLock;
-use trust_dns::op::{Message, MessageType, OpCode, Query, ResponseCode};
-use trust_dns::rr::dnssec::SupportedAlgorithms;
-use trust_dns::rr::{Name, Record, RecordType as TrustRecordType};
+use trust_dns_proto::op::{Message, MessageType, OpCode, Query, ResponseCode};
+use trust_dns_proto::rr::dnssec::SupportedAlgorithms;
+use trust_dns_proto::rr::{Name, Record, RecordType as TrustRecordType};
 use trust_dns_server::authority::{AuthLookup, Authority};
+use trust_dns_server::authority::AuthLookupIter::Records;
 use trust_dns_server::server::{Request, RequestHandler};
+use trust_dns_server::authority::LookupError;
+use trust_dns_server::store::in_memory::InMemoryAuthority;
+
 
 use super::code::CodeName;
 use super::health::{DNSHealth, DNSHealthStatus};
@@ -25,18 +29,36 @@ use crate::geo::region::RegionCode;
 use crate::store::store::{StoreError, StoreRecord};
 use crate::APP_CONF;
 use crate::APP_STORE;
+use trust_dns_server::server::ResponseHandler;
+use trust_dns_server::authority::MessageResponseBuilder;
+use std::future::Future;
+use trust_dns_server::authority::MessageResponse;
+
+pub type Authority2 = InMemoryAuthority;
 
 pub struct DNSHandler {
-    authorities: HashMap<Name, RwLock<Authority>>,
+    authorities: HashMap<Name, RwLock<Authority2>>,
+}
+
+
+pub struct DoneNow;
+
+impl Future for DoneNow {
+    type Output = ();
+    fn poll(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
+        Poll::Ready(())
+    }
 }
 
 impl RequestHandler for DNSHandler {
-    fn handle_request(&self, request: &Request) -> Message {
+    type ResponseFuture=DoneNow;
+
+    fn handle_request<R: ResponseHandler>(&self, request: Request, response_handle: R) -> Self::ResponseFuture {
         let request_message = &request.message;
 
         trace!("request: {:?}", request_message);
 
-        let response: Message = match request_message.message_type() {
+        let response: MessageResponse = match request_message.message_type() {
             MessageType::Query => match request_message.op_code() {
                 OpCode::Query => {
                     let response = self.lookup(request.src.ip(), &request_message);
@@ -48,7 +70,7 @@ impl RequestHandler for DNSHandler {
                 code @ _ => {
                     error!("unimplemented opcode: {:?}", code);
 
-                    Message::error_msg(
+                    MessageResponseBuilder::error_msg(
                         request_message.id(),
                         request_message.op_code(),
                         ResponseCode::NotImp,
@@ -61,15 +83,15 @@ impl RequestHandler for DNSHandler {
                     request_message.id()
                 );
 
-                Message::error_msg(
+                MessageResponseBuilder::error_msg(
                     request_message.id(),
                     request_message.op_code(),
                     ResponseCode::NotImp,
                 )
             }
         };
 
-        response
+        Box::pin(response_handle.send_response(response).into())
     }
 }
 
@@ -80,7 +102,7 @@ impl DNSHandler {
         }
     }
 
-    pub fn upsert(&mut self, name: Name, authority: Authority) {
+    pub fn upsert(&mut self, name: Name, authority: Authority2) {
         self.authorities.insert(name, RwLock::new(authority));
     }
 
@@ -106,7 +128,8 @@ impl DNSHandler {
                 let supported_algorithms = SupportedAlgorithms::new();
 
                 // Attempt to resolve from local store
-                let records_local = authority.search(query, false, supported_algorithms);
+                let mut rt = tokio::runtime::Runtime::new().unwrap();
+                let records_local = rt.block_on(async { authority.search(query, false, supported_algorithms) } );
 
                 if !records_local.is_empty() {
                     debug!("found records for query from local store: {}", query);
@@ -172,7 +195,7 @@ impl DNSHandler {
                                             false,
                                         );
                                     }
-                                    AuthLookup::Records(..) => {
+                                    AuthLookup::Records {.. } => {
                                         panic!("error, should return noerror")
                                     }
                                 };
@@ -203,7 +226,7 @@ impl DNSHandler {
         response
     }
 
-    fn find_auth_recurse(&self, name: &Name) -> Option<&RwLock<Authority>> {
+    fn find_auth_recurse(&self, name: &Name) -> Option<&RwLock<Authority2>> {
         let authority = self.authorities.get(name);
 
         if authority.is_some() {
@@ -220,7 +243,7 @@ impl DNSHandler {
     }
 
     fn records_from_store(
-        authority: &Authority,
+        authority: &Authority2,
         zone_name: &Option<ZoneName>,
         source: IpAddr,
         query: &Query,
@@ -286,7 +309,7 @@ impl DNSHandler {
     }
 
     fn records_from_store_attempt(
-        authority: &Authority,
+        authority: &Authority2,
         source: IpAddr,
         zone_name: &Option<ZoneName>,
         query_name_client: &Name,
@@ -550,7 +573,7 @@ impl DNSHandler {
         response: &mut Message,
         zone_name: &Option<ZoneName>,
         mut records: Vec<Record>,
-        authority: &Authority,
+        authority: &Authority2,
         supported_algorithms: SupportedAlgorithms,
     ) {
         let has_records = !records.is_empty();
@@ -580,7 +603,7 @@ impl DNSHandler {
     fn stamp_response(
         request: &Message,
         response: &mut Message,
-        authority: &Authority,
+        authority: &Authority2,
         supported_algorithms: SupportedAlgorithms,
         code: ResponseCode,
         zone_name: &Option<ZoneName>,
@@ -638,6 +661,6 @@ impl DNSHandler {
         }
 
         // No alternate record found, consider name as non-existing.
-        return Ok(false);
+        Ok(false)
     }
 }

src/dns/listen.rs

@@ -7,11 +7,13 @@
 use std::collections::BTreeMap;
 use std::net::{TcpListener, UdpSocket};
 use std::time::Duration;
-use trust_dns::rr::rdata::SOA;
-use trust_dns::rr::{Name, RData, Record, RecordSet, RecordType, RrKey};
+use trust_dns_proto::rr::rdata::SOA;
+use trust_dns_proto::rr::{Name, RData, Record, RecordSet, RecordType};
 use trust_dns_server::authority::{Authority, ZoneType};
 use trust_dns_server::server::ServerFuture;
 
+use super::handler::Authority2;
+
 use super::handler::DNSHandler;
 use crate::APP_CONF;
 
@@ -71,7 +73,7 @@ impl DNSListen {
         }
     }
 
-    fn map_authority(zone_name: &str) -> Result<(Name, Authority), ()> {
+    fn map_authority(zone_name: &str) -> Result<(Name, Authority2), ()> {
         if let Ok(name) = Name::parse(zone_name, Some(&Name::new())) {
             let mut records = BTreeMap::new();
 
@@ -91,7 +93,7 @@ impl DNSListen {
                 )),
             ));
 
-            records.insert(RrKey::new(&name, RecordType::SOA), soa_records);
+            records.insert(RecordSet::new(&name, RecordType::SOA, 1337), soa_records);
 
             // Insert base NS records
             let mut ns_records = RecordSet::new(&name, RecordType::NS, SERIAL_DEFAULT);
@@ -111,11 +113,11 @@ impl DNSListen {
                 );
             }
 
-            records.insert(RrKey::new(&name, RecordType::NS), ns_records);
+            records.insert(RecordSet::new(&name, RecordType::NS, 1337), ns_records);
 
             Ok((
                 name.to_owned(),
-                Authority::new(name, records, ZoneType::Master, false, false),
+                Authority2::new(name, records, ZoneType::Master, false, false),
             ))
         } else {
             Err(())

src/dns/record.rs

@@ -13,9 +13,9 @@ use std::cmp;
 use std::collections::HashSet;
 use std::ops::Deref;
 use std::{fmt, str};
-use trust_dns::rr::rdata::mx::MX;
-use trust_dns::rr::rdata::txt::TXT;
-use trust_dns::rr::{Name as TrustName, RData as TrustRData, RecordType as TrustRecordType};
+use trust_dns_proto::rr::rdata::mx::MX;
+use trust_dns_proto::rr::rdata::txt::TXT;
+use trust_dns_proto::rr::{Name as TrustName, RData as TrustRData, RecordType as TrustRecordType};
 
 use crate::geo::country::CountryCode;
 

src/dns/zone.rs

@@ -10,7 +10,7 @@ use rocket::request::FromParam;
 use serde::de::{Error as DeserializeError, Unexpected, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::{fmt, str};
-use trust_dns::rr::Name as TrustName;
+use trust_dns_proto::rr::Name as TrustName;
 
 use crate::APP_CONF;
 

src/main.rs

@@ -16,25 +16,25 @@ extern crate lazy_static;
 extern crate serde_derive;
 #[macro_use]
 extern crate rocket;
-extern crate base64;
-extern crate farmhash;
-extern crate flate2;
-extern crate http_req;
-extern crate maxminddb;
-extern crate r2d2;
-extern crate r2d2_redis;
-extern crate rand;
-extern crate redis;
-extern crate regex;
-extern crate rocket_contrib;
-extern crate serde;
-extern crate serde_json;
-extern crate tar;
-extern crate tempfile;
-extern crate toml;
-extern crate trust_dns;
-extern crate trust_dns_server;
-extern crate url_serde;
+use base64;
+use farmhash;
+use flate2;
+use http_req;
+use maxminddb;
+use r2d2;
+use r2d2_redis;
+use rand;
+use redis;
+use regex;
+use rocket_contrib;
+use serde;
+use serde_json;
+use tar;
+use tempfile;
+use toml;
+use trust_dns_proto;
+use trust_dns_server;
+use url_serde;
 
 mod config;
 mod dns;