PeachCloud
/
peach-dyndns-server
0
0
Fork 0
Code Issues 1 Pull Requests Projects Releases 1 Wiki Activity

Merge pull request #2 from peachcloud/latest 

Update code to use latest versions of trust_dns library
This commit is contained in:
Max Fowler 2021-04-28 13:11:06 +02:00 committed by GitHub
parent d1e34ab7d1 db24d7a7ae
commit e6a9dbbfe9
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 1080 additions and 992 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1942
Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

14
Cargo.toml
View File

@ -8,13 +8,13 @@ edition = "2018"
clap-log-flag = "0.2"
clap-verbosity-flag = "0.2"
log = "0.4"
futures = "0.1.26"
hyper = "0.12"
futures = "0.3.1"
hyper = { version = "0.14", features = ["full"] }
nest = "1"
structopt = "0.2"
tokio = "0.1"
tokio = { version = "1.5.0", features = ["full"] }
tokio-executor = "0.1"
tokio-tcp = "0.1"
tokio-udp = "0.1"
trust-dns = "0.16"
trust-dns-server = "0.16"
tokio-tcp = "0.1.4"
tokio-udp = "0.1.4"
trust-dns-server = "0.20.2"
trust-dns-client = "0.20.2"

48
src/dns.rs
View File

@ -2,20 +2,26 @@ use std::collections::BTreeMap;
use std::net::{IpAddr, Ipv4Addr, SocketAddr};
use std::str::FromStr;
use std::time::Duration;
use std::sync::{Arc, RwLock};
use futures::{future, Future};
use tokio_tcp::TcpListener;
use tokio_udp::UdpSocket;
use trust_dns::rr::rdata::soa::SOA;
use trust_dns::rr::{LowerName, Name, RData, Record, RecordSet, RecordType, RrKey};
use futures::future::join_all;
use tokio::net::TcpListener;
use tokio::net::UdpSocket;
use trust_dns_client::rr::rdata::soa::SOA;
use trust_dns_client::rr::{LowerName, Name, RData, Record, RecordSet, RecordType, RrKey};
use trust_dns_server;
use trust_dns_server::authority::{Catalog, ZoneType};
use trust_dns_server::server::ServerFuture;
use trust_dns_server::store::in_memory::InMemoryAuthority;
static DEFAULT_TCP_REQUEST_TIMEOUT: u64 = 5;
pub fn server() -> Box<Future<Item = (), Error = ()> + Send> {
pub async fn server() -> ServerFuture<Catalog> {
info!("Trust-DNS {} starting", trust_dns_server::version());
let ip_addr = IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0));
@ -23,10 +29,8 @@ pub fn server() -> Box<Future<Item = (), Error = ()> + Send> {
let tcp_request_timeout = Duration::from_secs(DEFAULT_TCP_REQUEST_TIMEOUT);
let sock_addr = SocketAddr::new(ip_addr, listen_port);
let udp_socket = UdpSocket::bind(&sock_addr)
.unwrap_or_else(|_| panic!("could not bind to udp: {}", sock_addr));
let tcp_listener = TcpListener::bind(&sock_addr)
.unwrap_or_else(|_| panic!("could not bind to tcp: {}", sock_addr));
let udp_socket = UdpSocket::bind(&sock_addr).await.expect("could not bind udp socket");
let tcp_listener = TcpListener::bind(&sock_addr).await.expect("could not bind tcp listener");
let mut catalog: Catalog = Catalog::new();
@ -76,22 +80,18 @@ pub fn server() -> Box<Future<Item = (), Error = ()> + Send> {
let dyn_record = Record::from_rdata(dyn_name, dyn_ttl, dyn_rdata);
authority.upsert(dyn_record, authority.serial());
catalog.upsert(LowerName::new(&authority_name), Box::new(authority));
catalog.upsert(LowerName::new(&authority_name), Box::new(Arc::new(RwLock::new(authority))));
let server = ServerFuture::new(catalog);
let mut server = ServerFuture::new(catalog);
Box::new(future::lazy(move || {
// load all the listeners
info!("DNS server listening for UDP on {:?}", udp_socket);
server.register_socket(udp_socket);
// load all the listeners
info!("DNS server listening for UDP on {:?}", udp_socket);
let udp_future = server.register_socket(udp_socket);
info!("DNS server listening for TCP on {:?}", tcp_listener);
server
.register_listener(tcp_listener, tcp_request_timeout)
.expect("DNS server could not register TCP listener");
info!("DNS server listening for TCP on {:?}", tcp_listener);
let tcp_future = server
.register_listener(tcp_listener, tcp_request_timeout);
info!("awaiting DNS connections...");
info!("awaiting DNS connections...");
future::empty()
}))
server
}

21
src/http.rs
View File

@ -1,21 +1,22 @@
use futures::Future;
use hyper::service::service_fn_ok;
use hyper::{Body, Request, Response, Server};
use std::convert::Infallible;
use hyper::service::{make_service_fn, service_fn};
fn handle_request(_req: Request<Body>) -> Response<Body> {
Response::new(Body::from("Hello, World!"))
async fn handle_request(_req: Request<Body>) -> Result<Response<Body>, Infallible>{
Ok(Response::new(Body::from("Hello, World!")))
}
pub fn server() -> Box<Future<Item = (), Error = ()> + Send> {
pub async fn server() {
let address = ([127, 0, 0, 1], 3000).into();
let handle_connection = || service_fn_ok(handle_request);
let make_svc = make_service_fn(|_conn| async {
// service_fn converts our function into a `Service`
Ok::<_, Infallible>(service_fn(handle_request))
});
info!("HTTP server listening for TCP on {:?}", address);
let server = Server::bind(&address)
.serve(handle_connection)
.map_err(|e| error!("HTTP server error: {}", e));
Box::new(server)
Server::bind(&address).serve(make_svc).await;
}

47
src/main.rs
View File

@ -2,40 +2,37 @@
extern crate log;
use std::io;
use futures::{future, Future};
use futures::{try_join, future, Future};
use nest::{Error, Store, Value};
use tokio::runtime::Runtime;
use tokio_executor;
use tokio::task;
mod cli;
mod dns;
mod http;
fn main() -> Result<(), Box<dyn std::error::Error>> {
let args = cli::args()?;
#[tokio::main]
async fn main() {
let mut runtime = Runtime::new().expect("error when creating tokio Runtime");
let args = cli::args().expect("error parsing args");
let main_future: Box<Future<Item = (), Error = ()> + Send> =
Box::new(future::lazy(move || {
tokio_executor::spawn(dns::server());
tokio_executor::spawn(http::server());
// create future for dns and http servers
let dns_future = task::spawn(dns::server());
let http_future = task::spawn(http::server());
future::empty()
}));
// join futures
let result = try_join!(dns_future, http_future);
if let Err(e) = runtime.block_on(main_future.map_err(|_| {
io::Error::new(
io::ErrorKind::Interrupted,
"Server stopping due to interruption",
)
})) {
error!("server failure: {}", e);
match result {
Err(e) => {
io::Error::new(
io::ErrorKind::Interrupted,
"Server stopping due to interruption",
);
error!("server failure: {}", e);
}
Ok(val) => {
info!("we're stopping for some unexpected reason");
}
}
// we're exiting for some reason...
info!("stopping!?");
Ok(())
info!("we're stopping for some unexpected reason");
}