Introduce a new net::server module

Cargo.toml

@@ -23,6 +23,7 @@ license = "BSD-3-Clause"
 domain-macros  = { path = "./macros", version = "0.10.3" }
 
 arbitrary      = { version = "1.4.1", optional = true, features = ["derive"] }
+bumpalo        = { version = "3.12", optional = true }
 octseq         = { version = "0.5.2", default-features = false }
 time           = { version = "0.3.1", default-features = false }
 rand           = { version = "0.8", optional = true }
@@ -74,7 +75,7 @@ zonefile    = ["bytes", "serde", "std"]
 
 # Unstable features
 unstable-client-transport = ["moka", "net", "tracing"]
-unstable-server-transport = ["arc-swap", "chrono/clock", "libc", "net", "siphasher", "tracing"]
+unstable-server-transport = ["dep:bumpalo", "arc-swap", "chrono/clock", "dep:log", "libc", "net", "rand", "siphasher", "tracing"]
 unstable-sign = ["std", "dep:secrecy", "unstable-validate", "time/formatting"]
 unstable-stelline = ["tokio/test-util", "tracing", "tracing-subscriber", "tsig", "unstable-client-transport", "unstable-server-transport", "zonefile"]
 unstable-validate = ["bytes", "std", "ring"]
@@ -99,6 +100,7 @@ tokio-rustls       = { version = "0.26", default-features = false, features = [
 tokio-test         = "0.4"
 tokio-tfo          = { version = "0.2.0" }
 webpki-roots       = { version = "0.26" }
+env_logger         = { version = "0.11" }
 
 # For the "mysql-zone" example
 #sqlx = { version = "0.6", features = [ "runtime-tokio-native-tls", "mysql" ] }
@@ -118,6 +120,10 @@ required-features = ["resolv"]
 name = "lookup"
 required-features = ["resolv"]
 
+[[example]]
+name = "new-server"
+required-features = ["net", "unstable-server-transport", "unstable-client-transport"]
+
 [[example]]
 name = "resolv-sync"
 required-features = ["resolv-sync"]

examples/new-server.rs

@@ -0,0 +1,92 @@
+use std::ops::ControlFlow;
+
+use log::trace;
+
+use domain::new_server::{
+    exchange::{OutgoingResponse, ResponseCode},
+    layers::{
+        cookie::{CookieMetadata, CookiePolicy, CookieSecrets},
+        CookieLayer,
+    },
+    transport, Exchange, LocalService, LocalServiceLayer, Service,
+    ServiceLayer,
+};
+
+pub struct MyService;
+
+impl Service for MyService {
+    async fn respond(&self, exchange: &mut Exchange<'_>) {
+        let cookie = exchange
+            .metadata
+            .iter()
+            .find_map(|m| m.try_as::<CookieMetadata>());
+
+        if let Some(CookieMetadata::ServerCookie { .. }) = cookie {
+            trace!(target: "MyService", "Request had a valid cookie");
+        } else {
+            trace!(target: "MyService", "Request did not have a valid cookie");
+        }
+
+        exchange.respond(ResponseCode::Success);
+
+        // Copy all questions from the request to the response.
+        exchange
+            .response
+            .questions
+            .append(&mut exchange.request.questions);
+    }
+}
+
+impl LocalService for MyService {
+    async fn respond_local(&self, exchange: &mut Exchange<'_>) {
+        self.respond(exchange).await
+    }
+}
+
+pub struct MyLayer;
+
+impl ServiceLayer for MyLayer {
+    async fn process_incoming(
+        &self,
+        exchange: &mut Exchange<'_>,
+    ) -> ControlFlow<()> {
+        trace!(target: "MyLayer",
+            "Incoming request (message ID {})",
+            exchange.request.id);
+        ControlFlow::Continue(())
+    }
+
+    async fn process_outgoing(&self, response: OutgoingResponse<'_, '_>) {
+        trace!(target: "MyLayer",
+            "Outgoing response (message ID {})",
+            response.response.id);
+    }
+}
+
+impl LocalServiceLayer for MyLayer {
+    async fn process_local_incoming(
+        &self,
+        exchange: &mut Exchange<'_>,
+    ) -> ControlFlow<()> {
+        self.process_incoming(exchange).await
+    }
+
+    async fn process_local_outgoing(
+        &self,
+        response: OutgoingResponse<'_, '_>,
+    ) {
+        self.process_outgoing(response).await
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    env_logger::init();
+
+    let addr = "127.0.0.1:8080".parse().unwrap();
+    let cookie_layer =
+        CookieLayer::new(CookiePolicy::default(), CookieSecrets::generate());
+    let service = (MyLayer, cookie_layer, MyService);
+    let result = transport::serve_udp(addr, service).await;
+    println!("Ended on result {result:?}");
+}

src/lib.rs

@@ -213,3 +213,5 @@ pub mod zonetree;
 pub mod new_base;
 pub mod new_edns;
 pub mod new_rdata;
+
+pub mod new_server;