async/client: Fix unary request timeout cleanup

[Tim-Zhang]

Summary

• apply one absolute deadline while a unary request waits for the outbound queue and its response
• remove stream registrations when requests time out or their futures are cancelled
• discard expired queued requests before writing, while closing connections interrupted during a write to avoid reusing a potentially partial frame
• propagate writer failures through the writer task result and add focused regression tests

Root cause

The previous timeout only covered waiting for the response after the request entered the outbound queue. A request could therefore outlive its timeout while the queue or socket was blocked, and timed-out or cancelled requests could leave stream registrations behind.

Validation

• cargo +1.95.0 test --features async
• cargo +1.95.0 clippy --all-targets --features async -- -D warnings
• cargo +1.95.0 fmt --all --check
• git diff --check

Fixes #317

[Copilot]

Pull request overview

This PR fixes async unary request timeout semantics so a single absolute deadline applies across outbound queue admission, socket write, and response wait, while also ensuring stream registrations are cleaned up on timeout/cancellation and writer failures propagate correctly.

Changes:

• Add per-message control metadata (deadline + cancellation detection) and use it to discard expired/cancelled queued requests and to close the connection if a write is interrupted mid-frame.
• Apply an absolute deadline to both outbound queue admission and response waiting for unary Client::request, with RAII cleanup for stream registrations.
• Refactor the connection writer task to return a Result and add regression tests covering queue saturation, expired queued requests, and cancellation during write.

Reviewed changes

Copilot reviewed 5 out of 5 changed files in this pull request and generated 1 comment.

Show a summary per file

File	Description
src/asynchronous/stream.rs	Introduces MessageControl (deadline + cancellation) attached to outbound SendingMessages.
src/asynchronous/server.rs	Updates ReaderDelegate::disconnect signature to match the new connection contract.
src/asynchronous/connection.rs	Refactors writer loop to enforce deadlines/cancellation during write, discard expired queued messages, and propagate writer errors to the connection runner.
src/asynchronous/client.rs	Applies an absolute deadline across unary request send + receive and adds RAII stream-registration cleanup; wires in tests module.
src/asynchronous/client_tests.rs	Adds focused async regression tests for deadline coverage, stream cleanup, and connection closure on cancelled in-progress writes.

---

💡 Add a code-review agent skill or configure MCP servers for context-aware, tailored reviews. Learn more in the docs.

[Copilot]

Pull request overview

Copilot reviewed 6 out of 6 changed files in this pull request and generated no new comments.

Suppressed comments (1)

src/asynchronous/client.rs:127

• The new absolute-deadline logic is only applied to Client::request (unary). Client::new_stream and streaming _send/StreamSender::{send,close_send} still enqueue SendingMessage::new(...) without any deadline/cancellation control and can still block indefinitely on a full outbound queue or a stuck writer, which is explicitly called out in #317. If this PR is meant to close #317 ("Fixes #317"), the same deadline mechanism should be plumbed through streaming paths and covered by regression tests; otherwise the PR description/issue linkage should be adjusted.

        let sending_msg = SendingMessage::new_with_control(msg, control);
        let send_result = if let Some(deadline) = deadline {
            timeout_at(deadline, self.req_tx.send(sending_msg))
                .await
                .map_err(|_| request_timeout_error())?