colin/hickory-dns
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

upgrade trust-dns to Tokio 0.3

Browse Source
This commit is contained in:
Benjamin Fry 2020-11-10 11:42:16 -08:00
parent 8fbb05a6f7
commit e7b291603d
6 changed files with 50 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
bin/benches/comparison_benches.rs
View File

@ -26,7 +26,7 @@ use trust_dns_client::rr::*;
use trust_dns_client::tcp::*;
use trust_dns_client::udp::*;
use trust_dns_proto::error::*;
use trust_dns_proto::iocompat::AsyncIo02As03;
use trust_dns_proto::iocompat::AsyncIoTokioAsStd;
use trust_dns_proto::xfer::*;
fn find_test_port() -> u16 {
@ -50,7 +50,7 @@ fn wrap_process(named: Child, server_port: u16) -> NamedProcess {
let mut started = false;
for _ in 0..20 {
let mut io_loop = Runtime::new().unwrap();
let io_loop = Runtime::new().unwrap();
let addr: SocketAddr = ("127.0.0.1", server_port)
.to_socket_addrs()
.unwrap()
@ -118,7 +118,7 @@ where
F: Future<Output = Result<S, ProtoError>> + 'static + Send + Unpin,
S: DnsRequestSender,
{
let mut io_loop = Runtime::new().unwrap();
let io_loop = Runtime::new().unwrap();
let client = AsyncClient::connect(stream);
let (mut client, bg) = io_loop.block_on(client).expect("failed to create client");
io_loop.spawn(bg);
@ -183,7 +183,7 @@ fn trust_dns_tcp_bench(b: &mut Bencher) {
.unwrap()
.next()
.unwrap();
let (stream, sender) = TcpClientStream::<AsyncIo02As03<TcpStream>>::new(addr);
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TcpStream>>::new(addr);
let mp = DnsMultiplexer::new(stream, sender, None::<Arc<Signer>>);
bench(b, mp);
@ -258,7 +258,7 @@ fn bind_tcp_bench(b: &mut Bencher) {
.unwrap()
.next()
.unwrap();
let (stream, sender) = TcpClientStream::<AsyncIo02As03<TcpStream>>::new(addr);
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TcpStream>>::new(addr);
let mp = DnsMultiplexer::new(stream, sender, None::<Arc<Signer>>);
bench(b, mp);

54
bin/src/named.rs
View File

@ -46,6 +46,7 @@ use trust_dns_server::authority::{AuthorityObject, Catalog, ZoneType};
use trust_dns_server::config::dnssec::{self, TlsCertConfig};
use trust_dns_server::config::{Config, ZoneConfig};
use trust_dns_server::logger;
use trust_dns_server::resolver::TokioHandle;
use trust_dns_server::server::ServerFuture;
use trust_dns_server::store::file::{FileAuthority, FileConfig};
#[cfg(feature = "resolver")]
@ -107,12 +108,8 @@ fn load_zone(
}
#[cfg(feature = "resolver")]
Some(StoreConfig::Forward(ref config)) => {
let forwarder = ForwardAuthority::try_from_config(
zone_name,
zone_type,
config,
runtime.handle().clone(),
);
let forwarder =
ForwardAuthority::try_from_config(zone_name, zone_type, config, TokioHandle);
let forwarder = runtime.block_on(forwarder)?;
Box::new(forwarder)
@ -350,10 +347,9 @@ fn main() {
.unwrap_or_else(|| directory_config.clone());
// TODO: allow for num threads configured...
let mut runtime = runtime::Builder::new()
let mut runtime = runtime::Builder::new_multi_thread()
.enable_all()
.threaded_scheduler()
.core_threads(4)
.worker_threads(4)
.thread_name("trust-dns-server-runtime")
.build()
.expect("failed to initialize Tokio Runtime");
@ -394,8 +390,6 @@ fn main() {
#[cfg_attr(not(feature = "dns-over-tls"), allow(unused_mut))]
let mut server = ServerFuture::new(catalog);
let handle = runtime.handle().clone();
// load all the listeners
for udp_socket in &sockaddrs {
info!("binding UDP to {:?}", udp_socket);
@ -410,7 +404,8 @@ fn main() {
.expect("could not lookup local address")
);
handle.enter(|| server.register_socket(udp_socket));
let _guard = runtime.enter();
server.register_socket(udp_socket);
}
// and TCP as necessary
@ -427,7 +422,8 @@ fn main() {
.expect("could not lookup local address")
);
handle.enter(|| server.register_listener(tcp_listener, tcp_request_timeout));
let _guard = runtime.enter();
server.register_listener(tcp_listener, tcp_request_timeout);
}
let tls_cert_config = config.get_tls_cert();
@ -510,8 +506,6 @@ fn config_tls(
warn!("a tls certificate was specified, but no TLS addresses configured to listen on");
}
let handle = runtime.handle().clone();
for tls_listener in &tls_sockaddrs {
info!(
"loading cert for DNS over TLS: {:?}",
@ -534,11 +528,10 @@ fn config_tls(
.expect("could not lookup local address")
);
handle.enter(|| {
server
.register_tls_listener(tls_listener, config.get_tcp_request_timeout(), tls_cert)
.expect("could not register TLS listener")
});
let _guard = runtime.enter();
server
.register_tls_listener(tls_listener, config.get_tcp_request_timeout(), tls_cert)
.expect("could not register TLS listener");
}
}
@ -566,8 +559,6 @@ fn config_https(
warn!("a tls certificate was specified, but no HTTPS addresses configured to listen on");
}
let handle = runtime.handle().clone();
for https_listener in &https_sockaddrs {
info!(
"loading cert for DNS over TLS named {} from {:?}",
@ -591,16 +582,15 @@ fn config_https(
.expect("could not lookup local address")
);
handle.enter(|| {
server
.register_https_listener(
https_listener,
config.get_tcp_request_timeout(),
tls_cert,
tls_cert_config.get_endpoint_name().to_string(),
)
.expect("could not register TLS listener")
});
let _guard = runtime.enter();
server
.register_https_listener(
https_listener,
config.get_tcp_request_timeout(),
tls_cert,
tls_cert_config.get_endpoint_name().to_string(),
)
.expect("could not register TLS listener");
}
}

4
bin/tests/named_https_tests.rs
View File

@ -24,7 +24,7 @@ use tokio::net::TcpStream as TokioTcpStream;
use tokio::runtime::Runtime;
use trust_dns_client::client::*;
use trust_dns_https::HttpsClientStreamBuilder;
use trust_dns_proto::iocompat::AsyncIo02As03;
use trust_dns_proto::iocompat::AsyncIoTokioAsStd;
use server_harness::{named_test_harness, query_a};
@ -73,7 +73,7 @@ fn test_example_https_toml_startup() {
let https_builder = HttpsClientStreamBuilder::with_client_config(client_config);
let mp = https_builder
.build::<AsyncIo02As03<TokioTcpStream>>(addr, "ns.example.com".to_string());
.build::<AsyncIoTokioAsStd<TokioTcpStream>>(addr, "ns.example.com".to_string());
let client = AsyncClient::connect(mp);
// ipv4 should succeed

6
bin/tests/named_test_rsa_dnssec.rs
View File

@ -20,7 +20,7 @@ use trust_dns_client::proto::tcp::TcpClientStream;
use trust_dns_client::proto::xfer::{DnsExchangeBackground, DnsMultiplexer};
use trust_dns_client::proto::DnssecDnsHandle;
use trust_dns_client::rr::dnssec::*;
use trust_dns_proto::{iocompat::AsyncIo02As03, TokioTime};
use trust_dns_proto::{iocompat::AsyncIoTokioAsStd, TokioTime};
use server_harness::*;
@ -61,7 +61,7 @@ async fn standard_tcp_conn(
) -> (
AsyncClient,
DnsExchangeBackground<
DnsMultiplexer<TcpClientStream<AsyncIo02As03<TokioTcpStream>>, Signer>,
DnsMultiplexer<TcpClientStream<AsyncIoTokioAsStd<TokioTcpStream>>, Signer>,
TokioTime,
>,
) {
@ -70,7 +70,7 @@ async fn standard_tcp_conn(
.unwrap()
.next()
.unwrap();
let (stream, sender) = TcpClientStream::<AsyncIo02As03<TokioTcpStream>>::new(addr);
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TokioTcpStream>>::new(addr);
AsyncClient::new(stream, sender, None)
.await
.expect("new AsyncClient failed")

30
bin/tests/named_tests.rs
View File

@ -29,7 +29,7 @@ use trust_dns_client::udp::UdpClientStream;
// use trust_dns_openssl::TlsClientStreamBuilder;
use server_harness::{named_test_harness, query_a};
use trust_dns_proto::iocompat::AsyncIo02As03;
use trust_dns_proto::iocompat::AsyncIoTokioAsStd;
#[test]
fn test_example_toml_startup() {
@ -39,7 +39,7 @@ fn test_example_toml_startup() {
Ipv4Addr::new(127, 0, 0, 1).into(),
tcp_port.expect("no tcp_port"),
);
let (stream, sender) = TcpClientStream::<AsyncIo02As03<TokioTcpStream>>::new(addr);
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TokioTcpStream>>::new(addr);
let client = AsyncClient::new(Box::new(stream), sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
@ -52,7 +52,7 @@ fn test_example_toml_startup() {
Ipv4Addr::new(127, 0, 0, 1).into(),
tcp_port.expect("no tcp_port"),
);
let (stream, sender) = TcpClientStream::<AsyncIo02As03<TokioTcpStream>>::new(addr);
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TokioTcpStream>>::new(addr);
let client = AsyncClient::new(Box::new(stream), sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
@ -70,7 +70,7 @@ fn test_ipv4_only_toml_startup() {
Ipv4Addr::new(127, 0, 0, 1).into(),
tcp_port.expect("no tcp_port"),
);
let (stream, sender) = TcpClientStream::<AsyncIo02As03<TokioTcpStream>>::new(addr);
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TokioTcpStream>>::new(addr);
let client = AsyncClient::new(Box::new(stream), sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
@ -83,7 +83,7 @@ fn test_ipv4_only_toml_startup() {
Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).into(),
tcp_port.expect("no tcp_port"),
);
let (stream, sender) = TcpClientStream::<AsyncIo02As03<TokioTcpStream>>::new(addr);
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TokioTcpStream>>::new(addr);
let client = AsyncClient::new(Box::new(stream), sender, None);
assert!(io_loop.block_on(client).is_err());
@ -133,7 +133,7 @@ fn test_ipv4_and_ipv6_toml_startup() {
Ipv4Addr::new(127, 0, 0, 1).into(),
tcp_port.expect("no tcp_port"),
);
let (stream, sender) = TcpClientStream::<AsyncIo02As03<TokioTcpStream>>::new(addr);
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TokioTcpStream>>::new(addr);
let client = AsyncClient::new(Box::new(stream), sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
@ -145,7 +145,7 @@ fn test_ipv4_and_ipv6_toml_startup() {
Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1).into(),
tcp_port.expect("no tcp_port"),
);
let (stream, sender) = TcpClientStream::<AsyncIo02As03<TokioTcpStream>>::new(addr);
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TokioTcpStream>>::new(addr);
let client = AsyncClient::new(Box::new(stream), sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
trust_dns_proto::spawn_bg(&io_loop, bg);
@ -158,12 +158,12 @@ fn test_ipv4_and_ipv6_toml_startup() {
#[test]
fn test_nodata_where_name_exists() {
named_test_harness("example.toml", |_, tcp_port, _, _| {
let mut io_loop = Runtime::new().unwrap();
let io_loop = Runtime::new().unwrap();
let addr: SocketAddr = SocketAddr::new(
Ipv4Addr::new(127, 0, 0, 1).into(),
tcp_port.expect("no tcp_port"),
);
let (stream, sender) = TcpClientStream::<AsyncIo02As03<TokioTcpStream>>::new(addr);
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TokioTcpStream>>::new(addr);
let client = AsyncClient::new(Box::new(stream), sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
trust_dns_proto::spawn_bg(&io_loop, bg);
@ -183,12 +183,12 @@ fn test_nodata_where_name_exists() {
#[test]
fn test_nxdomain_where_no_name_exists() {
named_test_harness("example.toml", |_, tcp_port, _, _| {
let mut io_loop = Runtime::new().unwrap();
let io_loop = Runtime::new().unwrap();
let addr: SocketAddr = SocketAddr::new(
Ipv4Addr::new(127, 0, 0, 1).into(),
tcp_port.expect("no tcp_port"),
);
let (stream, sender) = TcpClientStream::<AsyncIo02As03<TokioTcpStream>>::new(addr);
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TokioTcpStream>>::new(addr);
let client = AsyncClient::new(Box::new(stream), sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
trust_dns_proto::spawn_bg(&io_loop, bg);
@ -251,7 +251,7 @@ fn test_server_continues_on_bad_data_tcp() {
Ipv4Addr::new(127, 0, 0, 1).into(),
tcp_port.expect("no tcp_port"),
);
let (stream, sender) = TcpClientStream::<AsyncIo02As03<TokioTcpStream>>::new(addr);
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TokioTcpStream>>::new(addr);
let client = AsyncClient::new(Box::new(stream), sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
@ -271,7 +271,7 @@ fn test_server_continues_on_bad_data_tcp() {
Ipv4Addr::new(127, 0, 0, 1).into(),
tcp_port.expect("no tcp_port"),
);
let (stream, sender) = TcpClientStream::<AsyncIo02As03<TokioTcpStream>>::new(addr);
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TokioTcpStream>>::new(addr);
let client = AsyncClient::new(Box::new(stream), sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
trust_dns_proto::spawn_bg(&io_loop, bg);
@ -293,7 +293,7 @@ fn test_forward() {
Ipv4Addr::new(127, 0, 0, 1).into(),
tcp_port.expect("no tcp_port"),
);
let (stream, sender) = TcpClientStream::<AsyncIo02As03<TokioTcpStream>>::new(addr);
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TokioTcpStream>>::new(addr);
let client = AsyncClient::new(Box::new(stream), sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");
@ -315,7 +315,7 @@ fn test_forward() {
Ipv4Addr::new(127, 0, 0, 1).into(),
tcp_port.expect("no tcp_port"),
);
let (stream, sender) = TcpClientStream::<AsyncIo02As03<TokioTcpStream>>::new(addr);
let (stream, sender) = TcpClientStream::<AsyncIoTokioAsStd<TokioTcpStream>>::new(addr);
let client = AsyncClient::new(Box::new(stream), sender, None);
let (mut client, bg) = io_loop.block_on(client).expect("client failed to connect");

4
bin/tests/server_harness/mod.rs
View File

@ -91,7 +91,9 @@ where
}
kill_named();
panic!("timeout");
println!("Thread Killer has been awoken, killing process");
std::process::exit(-1);
})
.expect("could not start thread killer");