safe-async/hyperjive
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Remove DNS impl from hyperjive

Browse source
This commit is contained in:
Aode (lion) 2022-07-22 15:18:46 -05:00
parent 7a02440787
commit 8722ab5cf9
2 changed files with 7 additions and 172 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
Cargo.toml
View file

@ -19,27 +19,17 @@ required-features = ["client"]
[features]
default = ["client", "server"]
server = ["hyper/server"]
client = [
"async-trait",
"futures-io",
"hyper/client",
"jive/futures-io-compat",
"trust-dns-proto",
"trust-dns-resolver",
]
client = ["async-trait", "hyper/client", "jive-dns", "trust-dns-resolver"]
[dependencies]
async-trait = { version = "0.1.52", optional = true }
futures-io = { version = "0.3", optional = true }
hyper = { version = "0.14", features = ["http1"] }
hyper = { version = "0.14", default-features = false, features = ["http1"] }
jive = { git = "https://git.asonix.dog/safe-async/jive", features = [
"tokio-io-compat",
] }
tokio = { version = "1", default-features = false }
trust-dns-proto = { version = "0.21.0", default-features = false, optional = true }
trust-dns-resolver = { version = "0.21.1", default-features = false, features = [
"system-config",
], optional = true }
trust-dns-resolver = { version = "0.21.2", default-features = false, optional = true }
jive-dns = { git = "https://git.asonix.dog/safe-async/jive-dns", optional = true }
[dev-dependencies]
axum = "0.4.8"

161
src/lib.rs
View file

@ -97,8 +97,8 @@ pub mod server {
#[cfg(feature = "client")]
pub mod client {
use crate::common::{JiveRuntime, JiveTcpStream};
use dns::JiveResolver;
use hyper::{service::Service, Uri};
use jive_dns::JiveResolver;
use std::{
future::Future,
net::{IpAddr, SocketAddr},
@ -230,7 +230,7 @@ pub mod client {
impl ResolverService {
pub fn from_system_conf() -> Result<Self, trust_dns_resolver::error::ResolveError> {
Ok(ResolverService {
resolver: dns::resolver_from_system_conf()?,
resolver: jive_dns::resolver_from_system_conf()?,
})
}
@ -239,7 +239,7 @@ pub mod client {
options: trust_dns_resolver::config::ResolverOpts,
) -> Result<Self, trust_dns_resolver::error::ResolveError> {
Ok(ResolverService {
resolver: dns::resolver(config, options)?,
resolver: jive_dns::resolver(config, options)?,
})
}
}
@ -415,159 +415,4 @@ pub mod client {
}
}
}
pub mod dns {
use crate::common::{JiveRuntime, JiveTcpStream};
use futures_io::{AsyncRead, AsyncWrite};
use std::{
future::Future,
pin::Pin,
task::{Context, Poll},
};
use trust_dns_resolver::config::{ResolverConfig, ResolverOpts};
pub fn resolver(
config: ResolverConfig,
options: ResolverOpts,
) -> Result<JiveResolver, trust_dns_resolver::error::ResolveError> {
JiveResolver::new(config, options, JiveRuntimeHandle)
}
pub fn resolver_from_system_conf(
) -> Result<JiveResolver, trust_dns_resolver::error::ResolveError> {
JiveResolver::from_system_conf(JiveRuntimeHandle)
}
pub type JiveResolver =
trust_dns_resolver::AsyncResolver<JiveConnection, JiveConnectionProvider>;
pub type JiveConnection = trust_dns_resolver::name_server::GenericConnection;
pub type JiveConnectionProvider =
trust_dns_resolver::name_server::GenericConnectionProvider<JiveRuntime>;
#[derive(Clone, Copy)]
pub struct JiveRuntimeHandle;
pub struct JiveTimer;
pub struct JiveUdpSocket {
io: jive::io::Async<jive::net::UdpSocket>,
}
impl trust_dns_resolver::name_server::RuntimeProvider for JiveRuntime {
type Handle = JiveRuntimeHandle;
type Tcp = JiveTcpStream;
type Timer = JiveTimer;
type Udp = JiveUdpSocket;
}
impl trust_dns_resolver::name_server::Spawn for JiveRuntimeHandle {
fn spawn_bg<F>(&mut self, future: F)
where
F: Future<Output = Result<(), trust_dns_proto::error::ProtoError>> + Send + 'static,
{
let _join = jive::spawn(future);
}
}
#[async_trait::async_trait]
impl trust_dns_proto::tcp::Connect for JiveTcpStream {
async fn connect_with_bind(
addr: std::net::SocketAddr,
bind_addr: Option<std::net::SocketAddr>,
) -> std::io::Result<Self> {
if let Some(_bind_addr) = bind_addr {
todo!("Implement connect with bind");
} else {
let io = jive::io::Async::<jive::net::TcpStream>::connect(addr).await?;
Ok(JiveTcpStream { io })
}
}
}
impl trust_dns_proto::tcp::DnsTcpStream for JiveTcpStream {
type Time = JiveTimer;
}
impl AsyncRead for JiveTcpStream {
fn poll_read(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &mut [u8],
) -> Poll<std::io::Result<usize>> {
Pin::new(&mut self.get_mut().io).poll_read(cx, buf)
}
}
impl AsyncWrite for JiveTcpStream {
fn poll_write(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8],
) -> Poll<std::io::Result<usize>> {
Pin::new(&mut self.get_mut().io).poll_write(cx, buf)
}
fn poll_flush(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
Pin::new(&mut self.get_mut().io).poll_flush(cx)
}
fn poll_close(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<()>> {
Pin::new(&mut self.get_mut().io).poll_close(cx)
}
}
#[async_trait::async_trait]
impl trust_dns_proto::udp::UdpSocket for JiveUdpSocket {
type Time = JiveTimer;
async fn bind(addr: std::net::SocketAddr) -> std::io::Result<Self> {
let io = jive::io::Async::<jive::net::UdpSocket>::bind(addr).await?;
Ok(JiveUdpSocket { io })
}
fn poll_send_to(
&self,
cx: &mut Context<'_>,
buf: &[u8],
target: std::net::SocketAddr,
) -> Poll<std::io::Result<usize>> {
self.io.poll_send_to(cx, buf, target)
}
fn poll_recv_from(
&self,
cx: &mut Context<'_>,
buf: &mut [u8],
) -> Poll<std::io::Result<(usize, std::net::SocketAddr)>> {
self.io.poll_recv_from(cx, buf)
}
}
#[async_trait::async_trait]
impl trust_dns_proto::Time for JiveTimer {
async fn delay_for(duration: std::time::Duration) {
jive::time::sleep(duration).await
}
async fn timeout<F: 'static + Future + Send>(
duration: std::time::Duration,
future: F,
) -> Result<F::Output, std::io::Error> {
jive::time::timeout(duration, Box::pin(future)).await
}
}
impl trust_dns_proto::Executor for JiveRuntime {
fn new() -> Self {
Self
}
fn block_on<F: Future>(&mut self, future: F) -> F::Output {
jive::block_on(future)
}
}
}
}