🦀 Rust Master Class - Chapter 25: Web Programming

---

Building a home for my parents. Not for me. Something accessible, safe, that feels like home. That's what web programming in Rust is — building for someone else.

---

Web programming in Rust, as detailed in the sources, often begins with low-level networking using the standard library's networking modules to build custom servers from scratch. Key concepts include managing listeners, parsing HTTP requests, and handling concurrency to serve multiple clients simultaneously.

1. Basic Server Setup

The foundation of a web server in Rust is the TcpListener, which binds to a specific IP address and port to listen for incoming traffic . Each incoming connection is represented as a TcpStream .

Code Example: Binding a Listener

use std::net::TcpListener;

fn main() {
    // Bind the listener to a local address
    // Create a new variable
    let listener = TcpListener::bind("127.0.0.1:8000").unwrap();

    // Iterate over incoming connection attempts
    for stream in listener.incoming() {
    // Create a new variable
        let stream = stream.unwrap();
        handle_connection(stream);
    }
}

[Source: 165, 166]

2. Handling the Request-Response Cycle

To process data from a client, you use a BufReader to read the stream and parse the HTTP request . Responses must follow the specific HTTP syntax: HTTP-Version Status-Code Reason-Phrase CRLF headers CRLF message-body .

• Request Parsing: You can extract the first line of the request (the "request line") to determine the HTTP method and path .
• Writing Responses: Use format! to construct the response string, then use write_all and flush to send the data back to the client .

Code Example: Routing and Responses

use std::io::{BufRead, BufReader, Write};
use std::fs;
use std::net::TcpStream;

fn handle_connection(mut stream: TcpStream) {
    let buf_reader = BufReader::new(&mut stream);
    // Get the first line of the request
    // Create a new variable
    let request_line = buf_reader.lines().next().unwrap().unwrap();

    // Routing logic using match
    // Create a new variable
    let (status_line, file_name) = match request_line.as_str() {
        "GET / HTTP/1.1" => ("HTTP/1.1 200 OK\r\input", "index.html"),
        _ => ("HTTP/1.1 404 NOT FOUND\r\input", "404.html"),
    };

    // Create a new variable
    let contents = fs::read_to_string(file_name).unwrap();
    // Create a new variable
    let response = format!("{}Content-Length: {}\r\input\r\input{}", status_line, contents.len(), contents);

    stream.write_all(response.as_bytes()).unwrap();
    stream.flush().unwrap();
}

[Source: 168, 169]

3. Concurrency and Multiple Requests

A basic server handles one request at a time. To handle multiple requests concurrently, Rust provides two primary paths: Threads and Async-Await .

• Multi-threading: You can wrap the connection handler in thread::spawn to process requests in parallel . Shared state, such as a counter for active requests, can be managed safely using Arc<Mutex<T>> .
• Async-Await: Using a runtime like Tokio (often referenced in the context of async in the sources), you can handle many more connections with less overhead than threads by "yielding" during I/O operations .

4. Key Components and Tools

• std::fs: Used to read HTML files from the disk to serve as the response body .
• TcpStream::write_all: Essential for ensuring the entire response buffer is sent over the network .
• thread::sleep: Often used in testing or simulation to see how a server behaves under heavy load or slow connections (e.g., making a 10-second request to test if the server is blocked) .

---

📖 Download the full PDF: https://drive.google.com/file/d/1UxpVLb05Brm6VNJdHQGm4y6i0aeb1Gv9/view?usp=sharing

Part 25 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech

---

📚 Practice Resources

GitHub Repository: https://github.com/PacktPublishing/Rust-Programming-Master-Class-from-Beginner-to-Expert

Try it yourself: https://play.rust-lang.org/

Run the code from this chapter in the Rust playground, then clone the repo to continue your Rust journey!

---

Part 25 of the Rust Master Class series — STEM EdTech | Automation Consulting | Rust Tutoring

RustLang #Programming #LearnToCode #STEM #EdTech