← Graceful HTTP Shutdown networkingeasy ready

Problem

Graceful HTTP Shutdown (Rust)

Topics: TcpListener, connection draining, Condvar, shutdown lifecycle

Problem

Run an HTTP server that, on a shutdown signal, stops accepting new connections but lets in-flight requests finish — and gives up after a drain deadline. This is what makes a rolling deploy / pod eviction lossless instead of dropping live requests. Unlike the other HTTP challenges, this one uses a real std::net server (the lifecycle is the point).

pub struct Forced;   // returned when the drain deadline passes with requests still in flight

pub fn run<H>(listener: TcpListener, handler: H, cancel: Cancel, drain_timeout: Duration)
    -> Result<(), Forced>
where H: Fn(Request) -> Response + Send + Sync + 'static;

Serve handler on listener, one thread per connection (serve_conn is provided), until cancel fires.
On cancel, stop accepting new connections and wait up to drain_timeout for in-flight requests to finish.
Return Ok(()) if they drain in time, or Err(Forced) if the deadline passes first.

You implement run (the accept loop + in-flight tracking + drain); the HTTP plumbing (serve_conn) is provided.

Key concepts

Non-blocking accept: set_nonblocking(true) + a short poll lets the accept loop observe the cancel token instead of blocking forever.
In-flight tracking + Condvar: count active requests under a Mutex; on shutdown, dropping the listener stops new work, and Condvar::wait_timeout blocks until the count hits zero or the drain deadline — that timeout is the signal to return Forced.
Drain vs. force: draining preserves correctness for active requests; the deadline bounds how long shutdown can take so a stuck handler can't block a deploy forever. (Remaining handlers are left to finish on their own — the time bound is what matters; Go's srv.Close additionally severs their sockets.)

Grading

Your solution.rs is compiled together with a trusted tests.rs (which include!s it) using rustc --test. Only solution.rs is yours to edit.

Sign in to submit your solution.

Leaderboard score: lower is better, 1.0 ≈ reference

#	Name	score	ns/op	allocs

Output

No submission yet.

use std::io::{Read, Write};
use std::net::{TcpListener, TcpStream};
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::Arc;
use std::time::Duration;

/// A cooperative shutdown signal (stands in for Go's `context`).
#[derive(Clone, Default)]
pub struct Cancel(Arc<AtomicBool>);

impl Cancel {
    pub fn new() -> Self {
        Cancel(Arc::new(AtomicBool::new(false)))
    }
    pub fn cancel(&self) {
        self.0.store(true, Ordering::SeqCst);
    }
    pub fn is_cancelled(&self) -> bool {
        self.0.load(Ordering::SeqCst)
    }
}

#[derive(Clone, Default)]
pub struct Request {
    pub method: String,
    pub path: String,
}

pub struct Response {
    pub status: u16,
    pub body: String,
}

impl Response {
    pub fn new(status: u16) -> Self {
        Response {
            status,
            body: String::new(),
        }
    }
    pub fn with_body(mut self, body: &str) -> Self {
        self.body = body.to_string();
        self
    }
}

/// Returned when the drain deadline passes with requests still in flight.
#[derive(Debug, PartialEq, Eq)]
pub struct Forced;

/// Serves `handler` on `listener` until `cancel` fires, then drains in-flight
/// requests for up to `drain_timeout` before returning.
///
/// Implement the lifecycle: accept connections (each handled in its own thread
/// via `serve_conn`) while tracking how many are in flight; on cancel, stop
/// accepting; wait up to `drain_timeout` for the in-flight count to reach zero.
/// Return `Ok(())` if it drains in time, or `Err(Forced)` if the deadline passes
/// first. Tip: set the listener non-blocking so the accept loop can observe
/// `cancel`, and use a `Condvar` to wake the drain wait when a request finishes.
pub fn run<H>(
    listener: TcpListener,
    handler: H,
    cancel: Cancel,
    drain_timeout: Duration,
) -> Result<(), Forced>
where
    H: Fn(Request) -> Response + Send + Sync + 'static,
{
    let _ = (listener, handler, cancel, drain_timeout);
    unimplemented!()
}

/// Reads one HTTP/1.1 request, runs the handler, and writes the response.
/// (Provided — the HTTP plumbing isn't the point of this challenge.)
pub fn serve_conn<H: Fn(Request) -> Response>(mut stream: TcpStream, handler: &H) {
    stream.set_nonblocking(false).ok();

let mut buf = Vec::new();
    let mut tmp = [0u8; 1024];
    loop {
        match stream.read(&mut tmp) {
            Ok(0) => break,
            Ok(n) => {
                buf.extend_from_slice(&tmp[..n]);
                if buf.windows(4).any(|w| w == b"\r\n\r\n") || buf.len() > 65536 {
                    break;
                }
            }
            Err(_) => return,
        }
    }

let text = String::from_utf8_lossy(&buf);
    let mut fields = text.lines().next().unwrap_or("").split_whitespace();
    let method = fields.next().unwrap_or("GET").to_string();
    let path = fields.next().unwrap_or("/").to_string();

let resp = handler(Request { method, path });
    let body = resp.body.into_bytes();
    let head = format!(
        "HTTP/1.1 {} OK\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
        resp.status,
        body.len()
    );
    let _ = stream.write_all(head.as_bytes());
    let _ = stream.write_all(&body);
    let _ = stream.flush();
}