feat: publish Dever core with project scaffolding and versioned AI skills

test/dever-tests/tests/pooled_network.rs

@@ -0,0 +1,691 @@
+#[path = "support/wire_peer.rs"]
+mod wire_peer;
+
+use std::sync::{
+    Arc,
+    atomic::{AtomicBool, Ordering},
+};
+use std::time::Duration;
+
+use dever_runtime::{
+    async_stream::AsyncStream, bytes::Bytes, channel::Channel, http, net, task, tls, websocket,
+};
+use wire_peer::Peer;
+
+const ROOT: &[u8] = include_bytes!("../fixtures/tls/root.pem");
+const CERT: &[u8] = include_bytes!("../fixtures/tls/server.pem");
+const KEY: &[u8] = include_bytes!("../fixtures/tls/server-key.pem");
+
+fn bytes(value: &[u8]) -> Bytes {
+    Bytes::new(value.to_vec())
+}
+fn limits() -> http::Limits {
+    http::Limits {
+        header_bytes: 8192,
+        body_bytes: 65536,
+        timeout_ms: 1000,
+        connections: 2,
+        http2: None,
+    }
+}
+fn pool_limits() -> http::PoolLimits {
+    http::PoolLimits {
+        idle_ms: 1000,
+        chunk_bytes: 4,
+        read_ms: 500,
+    }
+}
+fn request(target: &str) -> http::Request {
+    http::Request {
+        method: "GET".into(),
+        target: target.into(),
+        headers: vec![],
+        body: bytes(b""),
+    }
+}
+fn trust() -> tls::ClientTls {
+    tls::client(&bytes(ROOT)).unwrap()
+}
+fn identity() -> tls::ServerTls {
+    tls::server(&bytes(CERT), &bytes(KEY)).unwrap()
+}
+fn run(future: impl std::future::Future<Output = Result<(), String>>) {
+    task::run_entry_with(
+        task::RuntimeConfig {
+            worker_threads: 1,
+            max_blocking_threads: 2,
+            task_capacity: 64,
+        },
+        async {
+            tokio::time::timeout(Duration::from_secs(8), future)
+                .await
+                .expect("bounded owned peers")
+        },
+    )
+    .unwrap();
+}
+async fn client(
+    port: i64,
+    limits: http::Limits,
+    pool: http::PoolLimits,
+) -> Result<http::HttpClient, String> {
+    http::client(
+        &format!("http://localhost:{port}"),
+        tls::system(),
+        limits,
+        pool,
+    )
+    .await
+}
+async fn accept(listener: &net::Listener) -> Result<Peer, String> {
+    Peer::new(net::accept(listener).await?)
+}
+
+#[test]
+fn pooled_requests_reuse_one_transport_and_preserve_wire_contracts() {
+    run(async {
+        let listener = net::listen("127.0.0.1", 0).await?;
+        let port = net::port(&listener)?;
+        let peer = task::run(async move {
+            let mut peer = accept(&listener).await?;
+            for index in 0..20 {
+                let head = peer.head().await?;
+                assert!(head.starts_with(&format!("GET /{index} HTTP/1.1\r\n")), "{head}");
+                assert!(head.to_ascii_lowercase().contains(&format!("host: localhost:{port}\r\n")));
+                peer.write(b"HTTP/1.1 200 OK\r\nContent-Length: 6\r\nSet-Cookie: a=1\r\nSet-Cookie: b=2\r\n\r\nabcdef").await?;
+            }
+            assert!(net::read(&peer.socket, 1).await?.is_none());
+            Ok(())
+        }).await?;
+        let client = client(port, limits(), pool_limits()).await?;
+        for index in 0..20 {
+            let response = http::request(&client, request(&format!("/{index}"))).await?;
+            assert_eq!(response.body.values(), b"abcdef");
+            assert_eq!(
+                response
+                    .headers
+                    .iter()
+                    .filter(|header| header.name == "set-cookie")
+                    .count(),
+                2
+            );
+        }
+        http::close_client(&client).await?;
+        task::wait(peer).await?;
+        Ok(())
+    });
+}
+
+#[test]
+fn streamed_response_delivers_early_chunks_past_the_header_deadline() {
+    run(async {
+        let listener = net::listen("127.0.0.1", 0).await?;
+        let port = net::port(&listener)?;
+        let gate = Channel::new(1).unwrap();
+        let signal = gate.clone();
+        let peer = task::run(async move {
+            let mut peer = accept(&listener).await?;
+            peer.head().await?;
+            peer.write(b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\nContent-Type: text/event-stream\r\n\r\n6\r\nhello!\r\n").await?;
+            signal.receive().await?;
+            task::sleep(80).await?;
+            peer.write(b"6\r\nworld!\r\n0\r\n\r\n").await?;
+            assert!(net::read(&peer.socket, 1).await?.is_none());
+            Ok(())
+        }).await?;
+        let mut bounded = limits();
+        bounded.timeout_ms = 40;
+        let client = client(port, bounded, pool_limits()).await?;
+        let response = http::open(&client, request("/events")).await?;
+        assert_eq!(response.body.pull().await.unwrap()?.values(), b"hell");
+        assert_eq!(response.body.pull().await.unwrap()?.values(), b"o!");
+        gate.send(()).await?;
+        let mut tail = Vec::new();
+        while let Some(chunk) = response.body.pull().await {
+            let chunk = chunk?;
+            assert!(chunk.values().len() <= 4);
+            tail.extend_from_slice(chunk.values());
+        }
+        assert_eq!(tail, b"world!");
+        http::close_client(&client).await?;
+        task::wait(peer).await?;
+        Ok(())
+    });
+}
+
+#[test]
+fn abandoned_response_releases_capacity_and_closes_incomplete_connection() {
+    run(async {
+        let listener = net::listen("127.0.0.1", 0).await?;
+        let port = net::port(&listener)?;
+        let peer = task::run(async move {
+            let mut first = accept(&listener).await?;
+            first.head().await?;
+            first
+                .write(b"HTTP/1.1 200 OK\r\nContent-Length: 100\r\n\r\na")
+                .await?;
+            assert!(net::read(&first.socket, 1).await?.is_none());
+            let mut second = accept(&listener).await?;
+            second.head().await?;
+            second
+                .write(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok")
+                .await?;
+            assert!(net::read(&second.socket, 1).await?.is_none());
+            Ok(())
+        })
+        .await?;
+        let mut bounded = limits();
+        bounded.connections = 1;
+        let client = client(port, bounded, pool_limits()).await?;
+        let first = http::open(&client, request("/first")).await?;
+        let pending_client = client.clone();
+        let pending =
+            task::run(async move { http::request(&pending_client, request("/second")).await })
+                .await?;
+        task::sleep(20).await?;
+        first.body.close();
+        assert_eq!(task::wait(pending).await?.body.values(), b"ok");
+        http::close_client(&client).await?;
+        task::wait(peer).await?;
+        Ok(())
+    });
+}
+
+#[test]
+fn closing_pool_wakes_head_waiters_queue_waiters_and_body_readers() {
+    run(async {
+        let listener = net::listen("127.0.0.1", 0).await?;
+        let port = net::port(&listener)?;
+        let accepted = Channel::new(1).unwrap();
+        let signal = accepted.clone();
+        let peer = task::run(async move {
+            let mut peer = accept(&listener).await?;
+            peer.head().await?;
+            signal.send(()).await?;
+            assert!(net::read(&peer.socket, 1).await?.is_none());
+            Ok(())
+        })
+        .await?;
+        let mut bounded = limits();
+        bounded.connections = 1;
+        let client = client(port, bounded, pool_limits()).await?;
+        let a = client.clone();
+        let first =
+            task::run(async move { Ok(http::open(&a, request("/first")).await.is_err()) }).await?;
+        accepted.receive().await?;
+        let b = client.clone();
+        let queued =
+            task::run(async move { Ok(http::open(&b, request("/queued")).await.is_err()) }).await?;
+        http::close_client(&client).await?;
+        http::close_client(&client).await?;
+        assert!(task::wait(first).await? && task::wait(queued).await?);
+        task::wait(peer).await?;
+
+        let listener = net::listen("127.0.0.1", 0).await?;
+        let port = net::port(&listener)?;
+        let peer = task::run(async move {
+            let mut peer = accept(&listener).await?;
+            peer.head().await?;
+            peer.write(b"HTTP/1.1 200 OK\r\nContent-Length: 10\r\n\r\n")
+                .await?;
+            assert!(net::read(&peer.socket, 1).await?.is_none());
+            Ok(())
+        })
+        .await?;
+        let client = self::client(port, limits(), pool_limits()).await?;
+        let body = http::open(&client, request("/body")).await?.body;
+        let reader = body.clone();
+        let pending = task::run(async move { Ok(reader.pull().await.unwrap().is_err()) }).await?;
+        http::close_client(&client).await?;
+        assert!(task::wait(pending).await?);
+        assert!(body.pull().await.is_none());
+        task::wait(peer).await?;
+        Ok(())
+    });
+}
+
+#[test]
+fn idle_expiry_closes_transport_without_another_request() {
+    run(async {
+        let listener = net::listen("127.0.0.1", 0).await?;
+        let port = net::port(&listener)?;
+        let peer = task::run(async move {
+            let mut peer = accept(&listener).await?;
+            peer.head().await?;
+            peer.write(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok")
+                .await?;
+            assert!(net::read(&peer.socket, 1).await?.is_none());
+            Ok(())
+        })
+        .await?;
+        let mut pool = pool_limits();
+        pool.idle_ms = 30;
+        let client = client(port, limits(), pool).await?;
+        http::request(&client, request("/")).await?;
+        tokio::time::timeout(Duration::from_millis(300), task::wait(peer))
+            .await
+            .unwrap()?;
+        http::close_client(&client).await?;
+        Ok(())
+    });
+}
+
+#[test]
+fn upload_is_chunked_and_pull_driven() {
+    run(async {
+        let listener = net::listen("127.0.0.1", 0).await?;
+        let port = net::port(&listener)?;
+        let accepted = Channel::new(1).unwrap();
+        let signal = accepted.clone();
+        let peer = task::run(async move {
+            let mut peer = accept(&listener).await?;
+            let head = peer.head().await?.to_ascii_lowercase();
+            assert!(head.starts_with("post /upload http/1.1\r\n"));
+            assert!(head.contains("transfer-encoding: chunked\r\n"));
+            assert_eq!(peer.chunk().await?, b"abc");
+            signal.send(()).await?;
+            assert_eq!(peer.chunk().await?, b"def");
+            assert!(peer.chunk().await?.is_empty());
+            peer.write(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok")
+                .await?;
+            assert!(net::read(&peer.socket, 1).await?.is_none());
+            Ok(())
+        })
+        .await?;
+        let client = client(port, limits(), pool_limits()).await?;
+        let input = Channel::new(1).unwrap();
+        input.send(Ok(bytes(b"abc"))).await?;
+        let source = input.clone().stream();
+        let sender_client = client.clone();
+        let upload = task::run(async move {
+            http::open_stream(
+                &sender_client,
+                http::StreamRequest {
+                    method: "POST".into(),
+                    target: "/upload".into(),
+                    headers: vec![],
+                    body: source,
+                },
+            )
+            .await
+        })
+        .await?;
+        accepted.receive().await?;
+        input.send(Ok(bytes(b"def"))).await?;
+        input.close().await?;
+        let response = task::wait(upload).await?;
+        assert_eq!(response.body.pull().await.unwrap()?.values(), b"ok");
+        assert!(response.body.pull().await.is_none());
+        http::close_client(&client).await?;
+        task::wait(peer).await?;
+        Ok(())
+    });
+}
+
+#[test]
+fn truncated_and_oversized_bodies_are_errors_and_stream_fault_is_terminal() {
+    run(async {
+        for wire in [
+            b"HTTP/1.1 200 OK\r\nContent-Length: 9\r\n\r\na".as_slice(),
+            b"HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n1\r\na\r\n0\r\nX-Trailer: bad\r\n\r\n".as_slice(),
+        ] {
+            let listener = net::listen("127.0.0.1", 0).await?;
+            let port = net::port(&listener)?;
+            let peer = task::run(async move {
+                let mut peer = accept(&listener).await?;
+                peer.head().await?;
+                peer.write(wire).await?;
+                peer.socket.close()?;
+                Ok(())
+            }).await?;
+            let client = client(port, limits(), pool_limits()).await?;
+            let body = http::open(&client, request("/")).await?.body;
+            let mut failures = 0;
+            while let Some(chunk) = body.pull().await { if chunk.is_err() { failures += 1; } }
+            assert_eq!(failures, 1);
+            assert!(body.pull().await.is_none());
+            http::close_client(&client).await?;
+            task::wait(peer).await?;
+        }
+        let listener = net::listen("127.0.0.1", 0).await?;
+        let port = net::port(&listener)?;
+        let peer = task::run(async move {
+            let mut peer = accept(&listener).await?;
+            peer.head().await?;
+            peer.write(b"HTTP/1.1 200 OK\r\nContent-Length: 4\r\n\r\n1234")
+                .await?;
+            assert!(net::read(&peer.socket, 1).await?.is_none());
+            Ok(())
+        })
+        .await?;
+        let mut bounded = limits();
+        bounded.body_bytes = 3;
+        let client = client(port, bounded, pool_limits()).await?;
+        assert!(
+            http::request(&client, request("/"))
+                .await
+                .unwrap_err()
+                .contains("body_bytes")
+        );
+        http::close_client(&client).await?;
+        task::wait(peer).await?;
+        Ok(())
+    });
+}
+
+#[test]
+fn upload_rejects_oversized_chunks_and_source_failure() {
+    run(async {
+        for chunk in [Ok(bytes(b"too large")), Err("source failed".to_owned())] {
+            let listener = net::listen("127.0.0.1", 0).await?;
+            let port = net::port(&listener)?;
+            let peer = task::run(async move {
+                let peer = accept(&listener).await?;
+                while net::read(&peer.socket, 4096).await?.is_some() {}
+                Ok(())
+            })
+            .await?;
+            let client = client(port, limits(), pool_limits()).await?;
+            let response = http::open_stream(
+                &client,
+                http::StreamRequest {
+                    method: "POST".into(),
+                    target: "/".into(),
+                    headers: vec![],
+                    body: AsyncStream::from_values([chunk]),
+                },
+            )
+            .await;
+            assert!(response.is_err());
+            http::close_client(&client).await?;
+            task::wait(peer).await?;
+        }
+        Ok(())
+    });
+}
+
+#[test]
+fn https_verifies_ca_and_hostname_and_keeps_server_alive_after_rejection() {
+    run(async {
+        let listener = net::listen("127.0.0.1", 0).await?;
+        let port = net::port(&listener)?;
+        let server = task::run(http::serve_tls(
+            |request| async move {
+                Ok(http::Response {
+                    status: 200,
+                    headers: vec![],
+                    body: Bytes::from_string(request.target),
+                })
+            },
+            listener,
+            limits(),
+            identity(),
+        ))
+        .await?;
+        let untrusted = http::client(
+            &format!("https://localhost:{port}"),
+            tls::system(),
+            limits(),
+            pool_limits(),
+        )
+        .await?;
+        assert!(
+            http::request(&untrusted, request("/untrusted"))
+                .await
+                .is_err()
+        );
+        http::close_client(&untrusted).await?;
+        let wrong_name = http::client(
+            &format!("https://127.0.0.1:{port}"),
+            trust(),
+            limits(),
+            pool_limits(),
+        )
+        .await?;
+        assert!(
+            http::request(&wrong_name, request("/wrong-name"))
+                .await
+                .is_err()
+        );
+        http::close_client(&wrong_name).await?;
+        let trusted = http::client(
+            &format!("https://localhost:{port}"),
+            trust(),
+            limits(),
+            pool_limits(),
+        )
+        .await?;
+        for path in ["/one", "/two"] {
+            assert_eq!(
+                http::request(&trusted, request(path)).await?.body.values(),
+                path.as_bytes()
+            );
+        }
+        http::close_client(&trusted).await?;
+        task::stop(server).await?;
+        assert!(tls::client(&bytes(b"not a certificate")).is_err());
+        assert!(tls::server(&bytes(CERT), &bytes(ROOT)).is_err());
+        Ok(())
+    });
+}
+
+#[test]
+fn wss_upgrade_duplex_and_close_share_the_tls_transport() {
+    run(async {
+        let listener = net::listen("127.0.0.1", 0).await?;
+        let port = net::port(&listener)?;
+        let ws_limits = websocket::Limits {
+            message_bytes: 1024,
+            idle_ms: 1000,
+            write_ms: 1000,
+        };
+        let live = http::LiveLimits {
+            chunk_bytes: 1024,
+            idle_ms: 1000,
+            heartbeat_ms: 100,
+        };
+        let server = task::run(http::serve_live_tls(
+            move |_, reply| async move {
+                let socket = websocket::accept(&reply, ws_limits).await?;
+                if let Some(message) = websocket::receive(&socket).await? {
+                    websocket::send(&socket, message).await?;
+                }
+                assert!(websocket::receive(&socket).await?.is_none());
+                Ok(())
+            },
+            listener,
+            limits(),
+            live,
+            identity(),
+        ))
+        .await?;
+        let socket =
+            websocket::open(&format!("wss://localhost:{port}/ws"), trust(), ws_limits).await?;
+        websocket::send(&socket, websocket::Message::Text("中文 TLS".into())).await?;
+        assert!(
+            matches!(websocket::receive(&socket).await?, Some(websocket::Message::Text(value)) if value == "中文 TLS")
+        );
+        websocket::close(&socket, 1000, "done").await?;
+        task::stop(server).await?;
+        Ok(())
+    });
+}
+
+#[test]
+fn graceful_shutdown_stops_accepting_and_finishes_active_response() {
+    run(async {
+        let listener = net::listen("127.0.0.1", 0).await?;
+        let port = net::port(&listener)?;
+        let gate = Channel::new(1).unwrap();
+        let release = gate.clone();
+        let returned = Arc::new(AtomicBool::new(false));
+        let completed = returned.clone();
+        let live = http::LiveLimits {
+            chunk_bytes: 1024,
+            idle_ms: 1000,
+            heartbeat_ms: 100,
+        };
+        let server = task::run(http::serve_live(
+            move |_, reply| {
+                let gate = gate.clone();
+                let returned = returned.clone();
+                async move {
+                    http::start(&reply, 200, vec![]).await?;
+                    http::write(&reply, bytes(b"first")).await?;
+                    gate.receive().await?;
+                    http::write(&reply, bytes(b"last")).await?;
+                    returned.store(true, Ordering::Release);
+                    Ok(())
+                }
+            },
+            listener.clone(),
+            limits(),
+            live,
+        ))
+        .await?;
+        let mut peer = Peer::connect(port).await?;
+        peer.write(b"GET / HTTP/1.1\r\nHost: test\r\n\r\n").await?;
+        peer.head().await?;
+        assert_eq!(peer.chunk().await?, b"first");
+        listener.close()?;
+        assert!(!completed.load(Ordering::Acquire));
+        release.send(()).await?;
+        assert_eq!(peer.chunk().await?, b"last");
+        assert!(peer.chunk().await?.is_empty());
+        task::wait(server).await?;
+        assert!(completed.load(Ordering::Acquire));
+        assert!(net::connect_timeout("127.0.0.1", port, 100).await.is_err());
+        Ok(())
+    });
+}
+
+#[test]
+fn task_scope_closes_an_escaped_pool_instead_of_detaching_drivers() {
+    run(async {
+        let child = task::run(async {
+            http::client("http://localhost:1", tls::system(), limits(), pool_limits()).await
+        })
+        .await?;
+        let pool = task::wait(child).await?;
+        assert_eq!(
+            http::open(&pool, request("/")).await.unwrap_err(),
+            "HTTP client is closed"
+        );
+        http::close_client(&pool).await?;
+        Ok(())
+    });
+}
+
+#[test]
+fn stopping_an_upload_closes_partial_request_and_pool_remains_usable() {
+    run(async {
+        let listener = net::listen("127.0.0.1", 0).await?;
+        let port = net::port(&listener)?;
+        let accepted = Channel::new(1).unwrap();
+        let signal = accepted.clone();
+        let peer = task::run(async move {
+            let mut first = accept(&listener).await?;
+            first.head().await?;
+            assert_eq!(first.chunk().await?, b"abc");
+            signal.send(()).await?;
+            assert!(net::read(&first.socket, 1).await?.is_none());
+            let mut next = accept(&listener).await?;
+            assert!(next.head().await?.starts_with("GET /next HTTP/1.1"));
+            next.write(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok")
+                .await?;
+            assert!(net::read(&next.socket, 1).await?.is_none());
+            Ok(())
+        })
+        .await?;
+        let mut bounded = limits();
+        bounded.connections = 1;
+        let client = client(port, bounded, pool_limits()).await?;
+        let chunks = Channel::new(1).unwrap();
+        chunks.send(Ok(bytes(b"abc"))).await?;
+        let stream = chunks.clone().stream();
+        let source = stream.clone();
+        let sender_client = client.clone();
+        let sender = task::run(async move {
+            let _response = http::open_stream(
+                &sender_client,
+                http::StreamRequest {
+                    method: "POST".into(),
+                    target: "/upload".into(),
+                    headers: vec![],
+                    body: source,
+                },
+            )
+            .await?;
+            Ok(())
+        })
+        .await?;
+        accepted.receive().await?;
+        task::stop(sender).await?;
+        assert!(stream.pull().await.is_none());
+        assert_eq!(
+            http::request(&client, request("/next"))
+                .await?
+                .body
+                .values(),
+            b"ok"
+        );
+        http::close_client(&client).await?;
+        task::wait(peer).await?;
+        Ok(())
+    });
+}
+
+#[test]
+fn pool_queue_and_body_deadlines_release_only_their_own_operations() {
+    run(async {
+        let listener = net::listen("127.0.0.1", 0).await?;
+        let port = net::port(&listener)?;
+        let peer = task::run(async move {
+            let mut first = accept(&listener).await?;
+            first.head().await?;
+            first
+                .write(b"HTTP/1.1 200 OK\r\nContent-Length: 100\r\n\r\na")
+                .await?;
+            assert!(net::read(&first.socket, 1).await?.is_none());
+            let mut next = accept(&listener).await?;
+            next.head().await?;
+            next.write(b"HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok")
+                .await?;
+            assert!(net::read(&next.socket, 1).await?.is_none());
+            Ok(())
+        })
+        .await?;
+        let mut bounded = limits();
+        bounded.connections = 1;
+        bounded.timeout_ms = 30;
+        let mut pool = pool_limits();
+        pool.read_ms = 30;
+        let client = client(port, bounded, pool).await?;
+        let body = http::open(&client, request("/first")).await?.body;
+        assert!(
+            http::request(&client, request("/queued"))
+                .await
+                .unwrap_err()
+                .contains("timed out")
+        );
+        assert_eq!(body.pull().await.unwrap()?.values(), b"a");
+        assert!(
+            body.pull()
+                .await
+                .unwrap()
+                .unwrap_err()
+                .contains("read timed out")
+        );
+        assert!(body.pull().await.is_none());
+        assert_eq!(
+            http::request(&client, request("/next"))
+                .await?
+                .body
+                .values(),
+            b"ok"
+        );
+        http::close_client(&client).await?;
+        task::wait(peer).await?;
+        Ok(())
+    });
+}