Working rocket server

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "peach-dyndns-host"
 version = "0.1.0"
-authors = ["Michael Williams <michael.williams@enspiral.com>"]
+authors = ["Michael Williams <michael.williams@enspiral.com>", "Max Fowler <notplants@mfowler.info>"]
 edition = "2018"
 
 [dependencies]
@@ -9,7 +9,6 @@ clap-log-flag = "0.2"
 clap-verbosity-flag = "0.2"
 log = "0.4"
 futures = "0.3.1"
-hyper = { version = "0.14", features = ["full"] }
 nest = "1"
 structopt = "0.2"
 tokio = { version = "1.5.0", features = ["full"] }
@@ -18,3 +17,6 @@ tokio-tcp = "0.1.4"
 tokio-udp = "0.1.4"
 trust-dns-server = "0.20.2"
 trust-dns-client = "0.20.2"
+rocket = { git = "https://github.com/SergioBenitez/Rocket", branch = "master" }
+rocket_contrib = { git = "https://github.com/SergioBenitez/Rocket", branch = "master" }
+serde = "1.0.125"

src/cli.rs

@@ -1,5 +1,3 @@
-use clap_log_flag;
-use clap_verbosity_flag;
 use structopt::StructOpt;
 
 #[derive(Debug, StructOpt)]

src/dns.rs

@@ -1,26 +1,18 @@
 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 futures::future::join_all;
+use std::time::Duration;
 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 async fn server() -> ServerFuture<Catalog> {
     info!("Trust-DNS {} starting", trust_dns_server::version());
 
@@ -29,8 +21,12 @@ pub async fn server() -> ServerFuture<Catalog> {
     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).await.expect("could not bind udp socket");
-    let tcp_listener = TcpListener::bind(&sock_addr).await.expect("could not bind tcp listener");
+    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();
 
@@ -80,17 +76,19 @@ pub async fn server() -> ServerFuture<Catalog> {
     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(Arc::new(RwLock::new(authority))));
+    catalog.upsert(
+        LowerName::new(&authority_name),
+        Box::new(Arc::new(RwLock::new(authority))),
+    );
 
     let mut server = ServerFuture::new(catalog);
 
     // load all the listeners
     info!("DNS server listening for UDP on {:?}", udp_socket);
-    let udp_future = server.register_socket(udp_socket);
+    server.register_socket(udp_socket);
 
     info!("DNS server listening for TCP on {:?}", tcp_listener);
-    let tcp_future = server
-        .register_listener(tcp_listener, tcp_request_timeout);
+    server.register_listener(tcp_listener, tcp_request_timeout);
     info!("awaiting DNS connections...");
 
     server

src/http.rs

@@ -1,22 +1,50 @@
-use futures::Future;
-use hyper::{Body, Request, Response, Server};
-use std::convert::Infallible;
-use hyper::service::{make_service_fn, service_fn};
+/*
+*
+* /register-user (sends an email verification to create a new account)
+* /verify (for clicking the link in the email)
+* /register-domain (add a new domain and get back the secret for subsequent updating)
+* /update-domain (update the IP for the domain, passing the associated secret)
+*
+*/
+use rocket_contrib::json::Json;
+use serde::Deserialize;
 
+#[get("/")]
+fn index() -> &'static str {
+    "This is the peach-dyn-dns server."
+}
 
-async fn handle_request(_req: Request<Body>) -> Result<Response<Body>, Infallible>{
-    Ok(Response::new(Body::from("Hello, World!")))
+#[derive(Deserialize, Debug)]
+struct RegisterDomainPost {
+    domain: String,
+}
+
+#[post("/register-domain", data = "<data>")]
+fn register_domain(data: Json<RegisterDomainPost>) -> &'static str {
+    info!("++ post request to register new domain: {:?}", data);
+    "New domain registered" // TODO: return secret
+}
+
+#[derive(Deserialize, Debug)]
+struct UpdateDomainPost {
+    domain: String,
+    secret: String,
+}
+
+#[post("/update-domain", data = "<data>")]
+fn update_domain(data: Json<UpdateDomainPost>) -> &'static str {
+    info!("++ post request to update domain: {:?}", data);
+    "Updating domain" // TODO: validate, then do it
 }
 
 pub async fn server() {
-    let address = ([127, 0, 0, 1], 3000).into();
 
-    let make_svc = make_service_fn(|_conn| async {
-        // service_fn converts our function into a `Service`
-        Ok::<_, Infallible>(service_fn(handle_request))
-    });
+    let rocket_result= rocket::build()
+        .mount("/", routes![index, register_domain, update_domain])
+        .launch()
+        .await;
 
-    info!("HTTP server listening for TCP on {:?}", address);
-
-    Server::bind(&address).serve(make_svc).await;
+    if let Err(err) = rocket_result {
+        error!("++ error launching rocket server: {:?}", err);
+    }
 }

src/main.rs

@@ -1,9 +1,10 @@
-#[macro_use]
-extern crate log;
+#![feature(proc_macro_hygiene, decl_macro)]
 
+#[macro_use]
+extern crate rocket;
+
+use futures::try_join;
 use std::io;
-use futures::{try_join, future, Future};
-use nest::{Error, Store, Value};
 use tokio::task;
 
 mod cli;
@@ -12,8 +13,7 @@ mod http;
 
 #[tokio::main]
 async fn main() {
-
-    let args = cli::args().expect("error parsing args");
+    let _args = cli::args().expect("error parsing args");
 
     // create future for dns and http servers
     let dns_future = task::spawn(dns::server());
@@ -30,7 +30,7 @@ async fn main() {
             );
             error!("server failure: {}", e);
         }
-        Ok(val) => {
+        Ok(_val) => {
             info!("we're stopping for some unexpected reason");
         }
     }