สร้างเว็บเซิร์ฟเวอร์แบบเธรดเดียว
เราจะเริ่มต้นด้วยการสร้างเว็บเซิร์ฟเวอร์ (web server) แบบเธรดเดียว (single-threaded) ให้ทำงานได้ก่อน ก่อนเริ่มลงมือเขียนโค้ด มาดูภาพรวมสั้น ๆ ของโปรโตคอล (protocols) ที่เกี่ยวข้องกับการสร้างเว็บเซิร์ฟเวอร์กันสักนิด แม้รายละเอียดเชิงลึกของโปรโตคอลเหล่านี้จะอยู่นอกเหนือขอบเขตของหนังสือเล่มนี้ แต่ภาพรวมโดยสังเขปจะช่วยปูพื้นฐานข้อมูลที่จำเป็นทั้งหมดที่คุณต้องใช้
โปรโตคอลหลักสองตัวที่เกี่ยวข้องกับเว็บเซิร์ฟเวอร์คือ Hypertext Transfer Protocol (HTTP) และ Transmission Control Protocol (TCP) ทั้งคู่จัดเป็นโปรโตคอลรูปแบบ คำขอ-การตอบกลับ (request-response) ซึ่งหมายความว่า ไคลเอนต์ (client) จะเป็นฝ่ายเริ่มส่งคำขอ (request) ส่วน เซิร์ฟเวอร์ (server) จะคอยรอรับคำขอดังกล่าวแล้วส่งการตอบกลับ (response) แก่ไคลเอนต์ โดยเนื้อหาของคำขอและการตอบกลับจะถูกกำหนดไว้ตามข้อกำหนดของโปรโตคอล
TCP เป็นโปรโตคอลระดับล่าง (lower-level) ที่อธิบายรายละเอียดการเดินทางของข้อมูลจากคอมพิวเตอร์เครื่องหนึ่งไปยังอีกเครื่องหนึ่ง แต่ไม่ได้ระบุว่าข้อมูลนั้นคืออะไร ส่วน HTTP จะสร้างต่อยอดขึ้นมาจาก TCP โดยกำหนดรูปแบบเนื้อหาของคำขอและการตอบกลับ แม้ในทางเทคนิคเราจะใช้ HTTP ร่วมกับโปรโตคอลอื่นได้ ทว่าในกรณีส่วนใหญ่แล้ว HTTP จะส่งข้อมูลผ่าน TCP และในบทนี้ เราจะทำงานกับข้อมูลไบต์ดิบ (raw bytes) ของคำขอและการตอบกลับทั้งในระดับ TCP และ HTTP
การรอฟังการเชื่อมต่อ TCP
เว็บเซิร์ฟเวอร์ของเราจำเป็นต้องคอยรอรับการเชื่อมต่อ TCP นี่จึงเป็นส่วนแรกที่เราจะลงมือสร้าง ไลบรารีมาตรฐานของ Rust มีมอดูล std::net สำหรับจัดการเรื่องนี้โดยเฉพาะ มาเริ่มสร้างโปรเจกต์ใหม่ตามขั้นตอนปกติกัน:
$ cargo new hello
Created binary (application) `hello` project
$ cd hello
ตอนนี้ให้ป้อนโค้ดในลิสติ้ง 21-1 ใน src/main.rs เพื่อเริ่มต้น โค้ดนี้จะรอฟังสตรีม (stream) TCP ที่เข้ามายังแอดเดรสภายในเครื่อง 127.0.0.1:7878 เมื่อได้รับสตรีมที่เข้ามา มันจะพิมพ์ Connection established!
use std::net::TcpListener;
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
println!("Connection established!");
}
}
การใช้ TcpListener ทำให้เราสามารถรอรับการเชื่อมต่อ TCP ที่แอดเดรส 127.0.0.1:7878 ได้ สำหรับแอดเดรสนี้ ส่วนที่อยู่ข้างหน้าเครื่องหมายโคลอนคือ IP address ที่แทนเครื่องคอมพิวเตอร์ของคุณเอง (ซึ่งมีค่าเหมือนกันบนทุกเครื่อง และไม่ได้ระบุถึงเครื่องของผู้เขียนโดยเฉพาะ) ส่วน 7878 คือหมายเลขพอร์ต (port) เราเลือกใช้พอร์ตนี้ด้วยเหตุผลสองประการ: ประการแรก โดยปกติพอร์ตนี้ไม่ได้ใช้รับส่งข้อมูล HTTP เซิร์ฟเวอร์ของเราจึงแทบไม่มีโอกาสชนกับเว็บเซิร์ฟเวอร์อื่นที่คุณอาจรันอยู่บนเครื่อง และประการที่สอง เลข 7878 หากกดแป้นพิมพ์โทรศัพท์ปุ่มตัวเลขจะสะกดได้เป็นคำว่า rust
ฟังก์ชัน bind ในบริบทนี้ทำงานคล้ายกับฟังก์ชัน new โดยจะคืนค่าอินสแตนซ์ใหม่ของ TcpListener ฟังก์ชันนี้ใช้ชื่อว่า bind เพราะในแวดวงระบบเครือข่าย การเชื่อมต่อไปยังพอร์ตเพื่อรอรับการเชื่อมต่อนั้นเรียกว่า “การผูกติดกับพอร์ต (binding to a port)”
ฟังก์ชัน bind จะคืนค่าเป็น Result<T, E> ซึ่งบ่งชี้ว่าการผูกพอร์ตอาจล้มเหลวได้ เช่น ในกรณีที่เรารันโปรแกรมนี้ขึ้นมาพร้อมกันสองอินสแตนซ์ ทำให้มีโปรแกรมสองตัวพยายามรอรับการเชื่อมต่อที่พอร์ตเดียวกัน แต่เนื่องจากเรากำลังเขียนเซิร์ฟเวอร์พื้นฐานเพื่อการเรียนรู้ เราจึงยังไม่ต้องกังวลกับการจัดการข้อผิดพลาดเหล่านี้ และจะเลือกใช้ unwrap เพื่อหยุดการทำงานของโปรแกรมทันทีหากเกิดข้อผิดพลาดขึ้น
เมธอด incoming บน TcpListener จะคืนค่าเป็นอิเทอเรเตอร์ (iterator) ที่ส่งมอบลำดับของสตรีม (stream) ให้แก่เรา (เจาะจงคือสตรีมชนิด TcpStream) โดย สตรีม หนึ่งตัวจะแทนการเชื่อมต่อที่เปิดอยู่ระหว่างไคลเอนต์กับเซิร์ฟเวอร์ คำว่า การเชื่อมต่อ (connection) เป็นชื่อเรียกกระบวนการรับส่งคำขอและการตอบกลับแบบครบวงจร ตั้งแต่ไคลเอนต์เชื่อมต่อไปยังเซิร์ฟเวอร์ เซิร์ฟเวอร์สร้างการตอบกลับ ไปจนถึงเซิร์ฟเวอร์ปิดการเชื่อมต่อลง ดังนั้นเราจึงสามารถอ่านข้อมูลจาก TcpStream เพื่อดูว่าไคลเอนต์ส่งสิ่งใดมา แล้วเขียนข้อมูลการตอบกลับของเราลงในสตรีมเพื่อส่งกลับไปยังไคลเอนต์ โดยสรุปแล้ว ลูป for นี้จะประมวลผลการเชื่อมต่อแต่ละรายการตามลำดับ และสร้างชุดของสตรีมออกมาให้เราจัดการ
ในตอนนี้ การจัดการสตรีมของเรามีเพียงการเรียก unwrap เพื่อหยุดโปรแกรมหากพบข้อผิดพลาดในสตรีม แต่หากไม่มีข้อผิดพลาด โปรแกรมก็จะพิมพ์ข้อความออกมา เราจะเพิ่มฟังก์ชันการทำงานในกรณีที่สำเร็จในลิสติ้งถัดไป สาเหตุที่เราอาจได้รับข้อผิดพลาดจากเมธอด incoming ขณะที่ไคลเอนต์เชื่อมต่อเข้ามาก็คือ ในความเป็นจริงแล้วเราไม่ได้กำลังวนซ้ำการเชื่อมต่อที่สมบูรณ์ แต่เรากำลังวนซ้ำ ความพยายามในการเชื่อมต่อ (connection attempts) ซึ่งการเชื่อมต่ออาจล้มเหลวได้จากหลายสาเหตุ โดยหลายสาเหตุมักขึ้นอยู่กับระบบปฏิบัติการโดยเฉพาะ เช่น ระบบปฏิบัติการหลายระบบมีขีดจำกัดจำนวนการเชื่อมต่อพร้อมกันที่สามารถเปิดค้างไว้ได้ หากมีความพยายามเชื่อมต่อใหม่เข้ามาเกินขีดจำกัดดังกล่าว ก็จะเกิดข้อผิดพลาดขึ้นจนกว่าการเชื่อมต่อที่เปิดอยู่บางส่วนจะปิดลง
มาลองรันโค้ดนี้กัน! เรียกใช้คำสั่ง cargo run ในเทอร์มินัล จากนั้นเปิดแอดเดรส 127.0.0.1:7878 บนเว็บเบราว์เซอร์ เบราว์เซอร์จะแสดงข้อผิดพลาด เช่น “Connection reset” เนื่องจากเซิร์ฟเวอร์ยังไม่ได้ส่งข้อมูลใด ๆ กลับไป แต่เมื่อคุณสลับมาดูที่เทอร์มินัล คุณจะเห็นข้อความปรากฏขึ้นหลายบรรทัดเมื่อเบราว์เซอร์เชื่อมต่อเข้ามายังเซิร์ฟเวอร์!
Running `target/debug/hello`
Connection established!
Connection established!
Connection established!
ในบางครั้งคุณอาจเห็นข้อความพิมพ์ซ้ำหลายครั้งสำหรับการเรียกหน้าเว็บบนเบราว์เซอร์เพียงครั้งเดียว สาเหตุอาจเกิดจากการที่เบราว์เซอร์ส่งคำขอเพื่อดึงหน้าเว็บ ควบคู่ไปกับคำขอทรัพยากรอื่น ๆ เช่น ไอคอน favicon.ico ที่แสดงบนแท็บของเบราว์เซอร์
อีกสาเหตุหนึ่งอาจเป็นเพราะเบราว์เซอร์พยายามเชื่อมต่อกับเซิร์ฟเวอร์ซ้ำหลายครั้งเนื่องจากเซิร์ฟเวอร์ไม่ได้ตอบกลับข้อมูลใด ๆ กลับไป เมื่อตัวแปร stream หลุดออกจากขอบเขต (scope) และถูกทำลายทิ้งที่จุดสิ้นสุดของลูป การเชื่อมต่อจะถูกปิดลงโดยอัตโนมัติผ่านการทำงานของ drop ซึ่งในบางครั้งเบราว์เซอร์จะรับมือกับการเชื่อมต่อที่ถูกปิดกะทันหันด้วยการลองส่งคำขอใหม่อีกครั้ง เนื่องจากประเมินว่าอาจเป็นปัญหาชั่วคราว
นอกจากนี้ เบราว์เซอร์บางตัวยังอาจเปิดการเชื่อมต่อทิ้งไว้หลายรายการโดยไม่ส่งคำขอใด ๆ เพื่อที่ว่าเมื่อถึงเวลาต้อง ส่งคำขอจริง คำขอนั้นจะเกิดขึ้นได้อย่างรวดเร็วทันที เมื่อเกิดเหตุการณ์นี้ขึ้น เซิร์ฟเวอร์ของเราจะมองเห็นการเชื่อมต่อแต่ละรายการเข้ามา ไม่ว่าจะมีข้อมูลคำขอส่งผ่านการเชื่อมต่อนั้นจริงหรือไม่ก็ตาม ตัวอย่างเช่น เบราว์เซอร์ตระกูล Chromium มักใช้วิธีนี้ คุณสามารถปิดการทำงานนี้ได้ด้วยการเปิดโหมดท่องเว็บแบบส่วนตัว (incognito/private mode) หรือเปลี่ยนไปใช้เบราว์เซอร์อื่น
สิ่งที่สำคัญที่สุดคือ ตอนนี้เราได้รับแฮนเดิล (handle) สำหรับการเชื่อมต่อ TCP ได้สำเร็จแล้ว!
อย่าลืมหยุดการทำงานของโปรแกรมโดยกด ctrl-C เมื่อคุณทดสอบโค้ดแต่ละรอบเสร็จสิ้น จากนั้นค่อยเริ่มรันโปรแกรมใหม่อีกครั้งด้วยคำสั่ง cargo run หลังจากแก้ไขโค้ดในแต่ละช่วง เพื่อให้มั่นใจว่าคุณกำลังรันโปรแกรมเวอร์ชันล่าสุดอยู่เสมอ
การอ่านคำขอ
มาเริ่มเขียนฟังก์ชันสำหรับอ่านข้อมูลคำขอที่ส่งมาจากเบราว์เซอร์กัน! เพื่อแยกหน้าที่การทำงาน (separation of concerns) ระหว่างการรับการเชื่อมต่อกับการจัดการสิ่งที่เกิดขึ้นบนการเชื่อมต่อนั้น เราจะสร้างฟังก์ชันใหม่ขึ้นมาสำหรับประมวลผลการเชื่อมต่อโดยเฉพาะ ในฟังก์ชัน handle_connection ใหม่นี้ เราจะอ่านข้อมูลจากสตรีม TCP แล้วพิมพ์ออกมาเพื่อให้เราเห็นข้อมูลที่เบราว์เซอร์ส่งมา ให้แก้ไขโค้ดตามลิสติ้ง 21-2
use std::{
io::{BufReader, prelude::*},
net::{TcpListener, TcpStream},
};
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
handle_connection(stream);
}
}
fn handle_connection(mut stream: TcpStream) {
let buf_reader = BufReader::new(&stream);
let http_request: Vec<_> = buf_reader
.lines()
.map(|result| result.unwrap())
.take_while(|line| !line.is_empty())
.collect();
println!("Request: {http_request:#?}");
}
เรานำ std::io::BufReader และ std::io::prelude เข้ามาสู่ขอบเขตการทำงานเพื่อให้สามารถเข้าถึงเทรต (traits) และชนิดข้อมูลที่ใช้ในการอ่านและเขียนข้อมูลลงสตรีมได้ และภายในลูป for ของฟังก์ชัน main แทนที่จะพิมพ์ข้อความแจ้งว่าเชื่อมต่อสำเร็จ เราจะเปลี่ยนมาเรียกฟังก์ชัน handle_connection และส่ง stream เข้าไปแทน
ภายในฟังก์ชัน handle_connection เราสร้างอินสแตนซ์ใหม่ของ BufReader ที่ครอบการอ้างอิง (reference) ไปยัง stream เอาไว้ ซึ่ง BufReader จะช่วยเพิ่มความสามารถในการบัฟเฟอร์ข้อมูล (buffering) โดยจัดการการเรียกใช้เมธอดต่าง ๆ จากเทรต std::io::Read ให้เราโดยอัตโนมัติ
เราสร้างตัวแปรชื่อ http_request เพื่อรวบรวมแต่ละบรรทัดของคำขอที่เบราว์เซอร์ส่งมายังเซิร์ฟเวอร์ของเรา และระบุว่าต้องการรวบรวมข้อมูลเหล่านี้ไว้ในเวกเตอร์ (vector) ด้วยการใส่คำกำกับชนิดข้อมูล (type annotation) เป็น Vec<_>
BufReader อิมพลีเมนต์เทรต std::io::BufRead ซึ่งมีเมธอด lines ให้ใช้งาน โดยเมธอด lines จะคืนค่าเป็นอิเทอเรเตอร์ของ Result<String, std::io::Error> จากการตัดแบ่งสตรีมข้อมูลทุกครั้งที่พบไบต์ขึ้นบรรทัดใหม่ (newline byte) และเพื่อให้ได้ข้อความ String แต่ละบรรทัด เราจึงใช้ map ร่วมกับ unwrap บนแต่ละค่า Result ทั้งนี้ ค่า Result อาจเป็นข้อผิดพลาดได้หากข้อมูลที่อ่านเข้ามาไม่ใช่ UTF-8 ที่ถูกต้อง หรือหากเกิดปัญหาในการอ่านข้อมูลจากสตรีม ซึ่งเช่นเคยว่า ในโปรแกรมระดับโปรดักชันจริงควรจัดการข้อผิดพลาดเหล่านี้อย่างรอบคอบและปลอดภัยกว่านี้ แต่ในที่นี้เราเลือกหยุดโปรแกรมทันทีหากเกิดข้อผิดพลาดเพื่อความกระชับและเข้าใจง่าย
เบราว์เซอร์จะส่งสัญญาณบ่งบอกจุดสิ้นสุดของคำขอ HTTP ด้วยการส่งอักขระขึ้นบรรทัดใหม่ 2 ตัวติดต่อกัน ดังนั้นเพื่อให้ได้คำขอครบถ้วนหนึ่งรายการจากสตรีม เราจึงอ่านข้อมูลทีละบรรทัดไปเรื่อย ๆ จนกระทั่งพบบรรทัดที่เป็นสตริงว่าง เมื่อรวบรวมบรรทัดทั้งหมดลงในเวกเตอร์เรียบร้อยแล้ว เราก็สั่งพิมพ์ข้อมูลออกมาด้วยรูปแบบการดีบักแบบสวยงาม เพื่อให้เราสามารถตรวจสอบเนื้อหาคำขอที่เว็บเบราว์เซอร์ส่งมายังเซิร์ฟเวอร์ได้อย่างชัดเจน
มาลองทดสอบโค้ดนี้กัน! รันโปรแกรมและเปิดส่งคำขอบนเว็บเบราว์เซอร์อีกครั้ง สังเกตว่าบนหน้าเบราว์เซอร์จะยังคงแสดงข้อผิดพลาดเหมือนเดิม แต่ข้อความเอาต์พุตของโปรแกรมในเทอร์มินัลจะมีหน้าตาดังต่อไปนี้:
$ cargo run
Compiling hello v0.1.0 (file:///projects/hello)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.42s
Running `target/debug/hello`
Request: [
"GET / HTTP/1.1",
"Host: 127.0.0.1:7878",
"User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:99.0) Gecko/20100101 Firefox/99.0",
"Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
"Accept-Language: en-US,en;q=0.5",
"Accept-Encoding: gzip, deflate, br",
"DNT: 1",
"Connection: keep-alive",
"Upgrade-Insecure-Requests: 1",
"Sec-Fetch-Dest: document",
"Sec-Fetch-Mode: navigate",
"Sec-Fetch-Site: none",
"Sec-Fetch-User: ?1",
"Cache-Control: max-age=0",
]
ข้อความเอาต์พุตของคุณอาจแตกต่างไปจากนี้เล็กน้อยขึ้นอยู่กับเบราว์เซอร์ที่ใช้ แต่เมื่อเราพิมพ์ข้อมูลคำขอออกมา เราจะเข้าใจได้ทันทีว่าทำไมการเรียกหน้าเว็บบนเบราว์เซอร์เพียงครั้งเดียวจึงเกิดการเชื่อมต่อเข้ามาหลายรายการ โดยสังเกตได้จากพาธ (path) ที่ตามหลังคำว่า GET ในบรรทัดแรกของคำขอ หากการเชื่อมต่อที่ซ้ำกันเหล่านั้นล้วนร้องขอ / นั่นแสดงว่าเบราว์เซอร์กำลังพยายามส่งคำขอดึงหน้า / ซ้ำ ๆ เนื่องจากยังไม่ได้รับการตอบกลับจากโปรแกรมของเรานั่นเอง
มาลองแยกชิ้นส่วนของข้อมูลคำขอนี้ เพื่อทำความเข้าใจให้ชัดเจนว่าเบราว์เซอร์กำลังร้องขอสิ่งใดจากโปรแกรมของเรา
การดูคำขอ HTTP อย่างใกล้ชิดยิ่งขึ้น
HTTP เป็นโปรโตคอลแบบข้อความ (text-based protocol) โดยคำขอมีรูปแบบมาตรฐานดังนี้:
Method Request-URI HTTP-Version CRLF
headers CRLF
message-body
บรรทัดแรกเรียกว่า บรรทัดคำขอ (request line) ซึ่งบรรจุข้อมูลเกี่ยวกับสิ่งที่ไคลเอนต์กำลังร้องขอ ส่วนแรกของบรรทัดคำขอจะระบุเมธอด (method) ที่ใช้ เช่น GET หรือ POST เพื่ออธิบายว่าไคลเอนต์ต้องการทำสิ่งใด ไคลเอนต์ของเราส่งคำขอเป็น GET ซึ่งหมายถึงการขอดึงข้อมูล
ส่วนถัดมาของบรรทัดคำขอคือ / ซึ่งระบุ uniform resource identifier (URI) ของทรัพยากรที่ไคลเอนต์กำลังร้องขอ แม้ว่า URI จะมีความหมายคล้ายคลึงกับ uniform resource locator (URL) เกือบทั้งหมดแต่ก็ไม่เหมือนกันเสียทีเดียว อย่างไรก็ตาม ความแตกต่างระหว่าง URI กับ URL ไม่ได้ส่งผลต่อเนื้อหาในบทนี้ แต่เนื่องจากข้อกำหนดมาตรฐานของ HTTP เลือกใช้คำว่า URI คุณจึงสามารถนึกภาพเปรียบเทียบคำว่า URI ตรงนี้เป็น URL ในใจได้เลย
ส่วนสุดท้ายคือเวอร์ชันของ HTTP ที่ไคลเอนต์ใช้ จากนั้นบรรทัดคำขอจะลงท้ายด้วยลำดับ CRLF (คำว่า CRLF ย่อมาจาก carriage return และ line feed ซึ่งเป็นคำที่สืบทอดมาจากยุคของเครื่องพิมพ์ดีด!) ลำดับ CRLF สามารถเขียนแทนได้ด้วย \r\n โดยที่ \r คือ carriage return และ \n คือ line feed ทั้งนี้ ลำดับ CRLF มีหน้าที่คั่นแบ่งบรรทัดคำขอออกจากข้อมูลส่วนที่เหลือของคำขอ และโปรดสังเกตว่าเมื่อพิมพ์ CRLF ออกมาทางหน้าจอ เราจะเห็นเป็นการขึ้นบรรทัดใหม่ ไม่ใช่ตัวอักษร \r\n
เมื่อพิจารณาข้อมูลบรรทัดคำขอที่เราได้รับจากการรันโปรแกรมจนถึงตอนนี้ จะเห็นว่า GET คือเมธอด, / คือ URI ของคำขอ และ HTTP/1.1 คือเวอร์ชัน
ถัดจากบรรทัดคำขอ บรรทัดที่เหลือทั้งหมดตั้งแต่ Host: เป็นต้นไปคือส่วนหัวของคำขอ หรือเฮดเดอร์ (headers) โดยคำขอแบบ GET จะไม่มีส่วนของเนื้อหา หรือบอดี้ (body)
ลองเปิดส่งคำขอจากเบราว์เซอร์ตัวอื่น หรือลองเรียกแอดเดรสอื่นดู เช่น 127.0.0.1:7878/test เพื่อสังเกตดูว่าข้อมูลของคำขอเปลี่ยนแปลงไปอย่างไรบ้าง
เมื่อเราเข้าใจแล้วว่าเบราว์เซอร์ส่งคำขออะไรมา คราวนี้มาเขียนโค้ดเพื่อส่งข้อมูลกลับไปกัน!
การเขียนการตอบกลับ
เราจะลงมือเขียนส่วนการส่งข้อมูลกลับไปเพื่อตอบรับคำขอจากไคลเอนต์ โดยโครงสร้างของการตอบกลับ (response) มีรูปแบบมาตรฐานดังนี้:
HTTP-Version Status-Code Reason-Phrase CRLF
headers CRLF
message-body
บรรทัดแรกเรียกว่า บรรทัดสถานะ (status line) ซึ่งประกอบด้วยเวอร์ชัน HTTP ที่ใช้ตอบกลับ, รหัสสถานะ (status code) แบบตัวเลขที่สรุปผลลัพธ์ของคำขอ และข้อความบอกเหตุผล (reason phrase) ที่อธิบายความหมายของรหัสสถานะนั้นเป็นข้อความ ถัดจากลำดับ CRLF จะเป็นส่วนของเฮดเดอร์ (headers) ตามด้วยลำดับ CRLF อีกชุดหนึ่ง แล้วจึงเป็นส่วนเนื้อหาของการตอบกลับ หรือบอดี้ (message-body)
ตัวอย่างด้านล่างคือข้อความตอบกลับที่ใช้ HTTP เวอร์ชัน 1.1 มีรหัสสถานะ 200 พร้อมข้อความเหตุผล OK โดยไม่มีทั้งเฮดเดอร์และบอดี้:
HTTP/1.1 200 OK\r\n\r\n
รหัสสถานะ 200 คือรหัสมาตรฐานที่บ่งบอกว่าการทำงานสำเร็จ ข้อความนี้จึงถือเป็นการตอบกลับ HTTP ที่สำเร็จในขนาดเล็กที่สุดเท่าที่จะทำได้ มาลองเขียนข้อความนี้ลงในสตรีมเพื่อตอบรับคำขอที่สำเร็จกัน! ในฟังก์ชัน handle_connection ให้ลบคำสั่ง println! ที่ใช้พิมพ์ข้อมูลคำขอออก แล้วแทนที่ด้วยโค้ดในลิสติ้ง 21-3
use std::{
io::{BufReader, prelude::*},
net::{TcpListener, TcpStream},
};
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
handle_connection(stream);
}
}
fn handle_connection(mut stream: TcpStream) {
let buf_reader = BufReader::new(&stream);
let http_request: Vec<_> = buf_reader
.lines()
.map(|result| result.unwrap())
.take_while(|line| !line.is_empty())
.collect();
let response = "HTTP/1.1 200 OK\r\n\r\n";
stream.write_all(response.as_bytes()).unwrap();
}
บรรทัดแรกที่เพิ่มเข้ามาจะนิยามตัวแปร response ขึ้นมาเก็บข้อความแจ้งความสำเร็จ จากนั้นเราเรียกใช้ as_bytes บนตัวแปร response เพื่อแปลงข้อมูลสตริงให้เป็นชุดของไบต์ เมธอด write_all บน stream จะรับค่าเป็น &[u8] แล้วส่งไบต์เหล่านั้นผ่านการเชื่อมต่อไปยังไคลเอนต์โดยตรง และเนื่องจากการทำงานของ write_all มีโอกาสล้มเหลวได้ เราจึงใช้ unwrap กับผลลัพธ์ที่อาจเป็นข้อผิดพลาดเช่นเดิม ซึ่งในแอปพลิเคชันจริง คุณควรใส่การจัดการข้อผิดพลาดที่เหมาะสม ณ จุดนี้
หลังจากแก้ไขโค้ดเรียบร้อยแล้ว มารันโปรแกรมและส่งคำขอบนเบราว์เซอร์กัน ตอนนี้เราไม่ได้พิมพ์ข้อมูลใด ๆ ออกทางเทอร์มินัลแล้ว เราจึงไม่เห็นเอาต์พุตอื่นนอกจากข้อความของ Cargo และเมื่อคุณเปิดหน้า 127.0.0.1:7878 บนเบราว์เซอร์ คุณจะเห็นเป็นหน้าเว็บว่างเปล่าสีขาวแทนที่จะแสดงข้อผิดพลาด ยินดีด้วย! คุณเพิ่งเขียนโค้ดรับคำขอ HTTP และส่งการตอบกลับด้วยตัวเองเสร็จเรียบร้อยแล้ว!
การคืนค่า HTML ของจริง
คราวนี้มาเพิ่มความสามารถให้เซิร์ฟเวอร์ส่งเนื้อหากลับไปมากกว่าแค่หน้าเว็บว่างเปล่ากัน ให้สร้างไฟล์ใหม่ชื่อ hello.html ไว้ที่รูทของไดเรกทอรีโปรเจกต์ (root directory ไม่ใช่ในโฟลเดอร์ src) คุณจะใส่เนื้อหา HTML ใด ๆ ตามที่ต้องการก็ได้ โดยลิสติ้ง 21-4 แสดงตัวอย่างโค้ด HTML รูปแบบหนึ่ง
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Hello!</title>
</head>
<body>
<h1>Hello!</h1>
<p>Hi from Rust</p>
</body>
</html>
นี่คือเอกสาร HTML5 ขนาดกะทัดรัดที่มีหัวข้อและข้อความสั้น ๆ เพื่อให้เซิร์ฟเวอร์ส่งเนื้อหานี้กลับไปเมื่อได้รับคำขอ เราจะแก้ไขฟังก์ชัน handle_connection ดังที่แสดงในลิสติ้ง 21-5 เพื่ออ่านไฟล์ HTML แล้วนำเนื้อหามาต่อท้ายการตอบกลับในฐานะบอดี้ก่อนจะส่งออกไป
use std::{
fs,
io::{BufReader, prelude::*},
net::{TcpListener, TcpStream},
};
// --snip--
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
handle_connection(stream);
}
}
fn handle_connection(mut stream: TcpStream) {
let buf_reader = BufReader::new(&stream);
let http_request: Vec<_> = buf_reader
.lines()
.map(|result| result.unwrap())
.take_while(|line| !line.is_empty())
.collect();
let status_line = "HTTP/1.1 200 OK";
let contents = fs::read_to_string("hello.html").unwrap();
let length = contents.len();
let response =
format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
stream.write_all(response.as_bytes()).unwrap();
}
เราได้เพิ่ม fs เข้าไปในสเตตเมนต์ use เพื่อนำมอดูลจัดการระบบไฟล์ของไลบรารีมาตรฐานเข้ามาใช้งาน โค้ดส่วนที่อ่านเนื้อหาของไฟล์ออกมาเป็นสตริงน่าจะคุ้นตากันดี เพราะเราเคยใช้รูปแบบนี้มาแล้วตอนอ่านไฟล์ในโปรเจกต์ I/O ในลิสติ้ง 12-4
ถัดมา เราใช้ format! เพื่อนำเนื้อหาของไฟล์มาใส่เป็นบอดี้ของการตอบกลับ และเพื่อให้การตอบกลับ HTTP ถูกต้องตามมาตรฐาน เราจึงได้เพิ่มเฮดเดอร์ Content-Length โดยกำหนดค่าเป็นขนาดของเนื้อหาบอดี้ ซึ่งในกรณีนี้ก็คือความยาวของเนื้อหาในไฟล์ hello.html
รันโค้ดนี้ด้วยคำสั่ง cargo run แล้วเปิดหน้า 127.0.0.1:7878 บนเบราว์เซอร์ คุณจะเห็นหน้าเว็บ HTML ของคุณถูกเรนเดอร์ขึ้นมาอย่างสวยงาม!
ในตอนนี้ เรายังไม่ได้นำข้อมูลคำขอในตัวแปร http_request มาพิจารณาเลย แต่เลือกส่งเนื้อหาของไฟล์ HTML กลับไปทันทีโดยไม่มีเงื่อนไขใด ๆ นั่นหมายความว่าหากคุณลองเรียก 127.0.0.1:7878/something-else บนเบราว์เซอร์ คุณก็จะยังได้รับหน้า HTML เดิมนี้กลับมาอยู่ดี ในขณะนี้ เซิร์ฟเวอร์ของเราจึงยังมีข้อจำกัดอย่างมากและยังทำงานได้ไม่เหมือนเว็บเซิร์ฟเวอร์ทั่วไป สิ่งที่เราต้องการคือการปรับแต่งการตอบกลับให้สอดคล้องกับคำขอ โดยส่งไฟล์ HTML กลับไปเฉพาะคำขอที่ถูกต้องและเรียกมายังพาธ / เท่านั้น
การตรวจสอบความถูกต้องของคำขอและการตอบกลับอย่างเลือกสรร
ในปัจจุบัน เว็บเซิร์ฟเวอร์ของเราจะส่งไฟล์ HTML กลับไปเสมอไม่ว่าไคลเอนต์จะร้องขอพาธใดก็ตาม มาเพิ่มฟังก์ชันการทำงานเพื่อตรวจสอบว่าเบราว์เซอร์ร้องขอพาธ / หรือไม่ ก่อนจะส่งไฟล์ HTML กลับไป และหากร้องขอพาธอื่นก็ให้ส่งข้อผิดพลาดกลับไปแทน ด้วยเหตุนี้ เราจึงต้องปรับแก้ฟังก์ชัน handle_connection ดังที่แสดงในลิสติ้ง 21-6 โค้ดใหม่นี้จะตรวจเช็กเนื้อหาของคำขอที่ได้รับเทียบกับรูปแบบคำขอที่เรียกมายัง / พร้อมทั้งเพิ่มบล็อก if และ else เพื่อจัดการแต่ละกรณีให้แตกต่างกัน
use std::{
fs,
io::{BufReader, prelude::*},
net::{TcpListener, TcpStream},
};
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
handle_connection(stream);
}
}
// --snip--
fn handle_connection(mut stream: TcpStream) {
let buf_reader = BufReader::new(&stream);
let request_line = buf_reader.lines().next().unwrap().unwrap();
if request_line == "GET / HTTP/1.1" {
let status_line = "HTTP/1.1 200 OK";
let contents = fs::read_to_string("hello.html").unwrap();
let length = contents.len();
let response = format!(
"{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}"
);
stream.write_all(response.as_bytes()).unwrap();
} else {
// some other request
}
}
เนื่องจากเราต้องการตรวจสอบเฉพาะบรรทัดแรกของคำขอ HTTP เท่านั้น ดังนั้นแทนที่จะอ่านคำขอทั้งหมดเก็บลงในเวกเตอร์ เราจึงเปลี่ยนมาเรียกเมธอด next เพื่อดึงรายการแรกจากอิเทอเรเตอร์ โดย unwrap ตัวแรกจะจัดการกับค่า Option และหยุดโปรแกรมหากอิเทอเรเตอร์ไม่มีข้อมูลใด ๆ ส่วน unwrap ตัวที่สองจะจัดการกับ Result ซึ่งให้ผลแบบเดียวกับ unwrap ใน map ที่เราเคยใส่ไว้ในลิสติ้ง 21-2
ถัดมา เราตรวจสอบตัวแปร request_line ว่าตรงกับบรรทัดคำขอของคำขอแบบ GET ที่เรียกไปยังพาธ / หรือไม่ หากตรงกัน บล็อก if จะส่งเนื้อหาของไฟล์ HTML ของเรากลับไป
หาก request_line ไม่ตรง กับคำขอ GET ไปยังพาธ / ก็แสดงว่าเราได้รับคำขอแบบอื่นเข้ามา ซึ่งเราจะเพิ่มโค้ดเข้าไปในบล็อก else ในลำดับถัดไปเพื่อจัดการกับคำขออื่น ๆ ทั้งหมดที่เหลือ
ลองรันโค้ดนี้แล้วเรียกไปยัง 127.0.0.1:7878 คุณจะได้รับหน้า HTML จากไฟล์ hello.html แต่ถ้าคุณส่งคำขออื่น เช่น 127.0.0.1:7878/something-else คุณจะพบกับข้อผิดพลาดในการเชื่อมต่อเหมือนที่เคยเห็นตอนรันโค้ดในลิสติ้ง 21-1 และ 21-2
คราวนี้มาเพิ่มโค้ดในลิสติ้ง 21-7 ลงในบล็อก else เพื่อส่งการตอบกลับที่มีรหัสสถานะ 404 ซึ่งบ่งบอกว่าไม่พบเนื้อหาที่ต้องการ (Not Found) และเราจะส่งหน้าเว็บ HTML กลับไปด้วยเพื่อให้เบราว์เซอร์เรนเดอร์ข้อความแจ้งเตือนแก่ผู้ใช้งาน
use std::{
fs,
io::{BufReader, prelude::*},
net::{TcpListener, TcpStream},
};
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
handle_connection(stream);
}
}
fn handle_connection(mut stream: TcpStream) {
let buf_reader = BufReader::new(&stream);
let request_line = buf_reader.lines().next().unwrap().unwrap();
if request_line == "GET / HTTP/1.1" {
let status_line = "HTTP/1.1 200 OK";
let contents = fs::read_to_string("hello.html").unwrap();
let length = contents.len();
let response = format!(
"{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}"
);
stream.write_all(response.as_bytes()).unwrap();
// --snip--
} else {
let status_line = "HTTP/1.1 404 NOT FOUND";
let contents = fs::read_to_string("404.html").unwrap();
let length = contents.len();
let response = format!(
"{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}"
);
stream.write_all(response.as_bytes()).unwrap();
}
}
ในกรณีนี้ การตอบกลับของเราจะมีบรรทัดสถานะที่ประกอบด้วยรหัสสถานะ 404 และข้อความบอกเหตุผล NOT FOUND โดยมีบอดี้เป็นการตอบกลับด้วย HTML จากไฟล์ 404.html คุณจะต้องสร้างไฟล์ 404.html วางไว้ข้าง ๆ hello.html สำหรับแสดงหน้าข้อผิดพลาดนี้ ซึ่งคุณสามารถใส่เนื้อหา HTML ใด ๆ ตามที่ต้องการ หรือนำตัวอย่าง HTML ในลิสติ้ง 21-8 ไปใช้ได้เลย
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Hello!</title>
</head>
<body>
<h1>Oops!</h1>
<p>Sorry, I don't know what you're asking for.</p>
</body>
</html>
เมื่อแก้ไขโค้ดเรียบร้อย ให้ลองรันเซิร์ฟเวอร์ใหม่อีกครั้ง การเรียก 127.0.0.1:7878 จะได้เนื้อหาของ hello.html ส่วนคำขออื่น ๆ เช่น 127.0.0.1:7878/foo จะได้หน้า HTML แจ้งข้อผิดพลาดจาก 404.html
การรีแฟกเตอร์
ในตอนนี้ บล็อก if และ else มีการทำงานที่ซ้ำซ้อนกันมาก ทั้งคู่อ่านไฟล์และเขียนเนื้อหาของไฟล์ลงในสตรีม โดยจุดที่ต่างกันมีเพียงบรรทัดสถานะกับชื่อไฟล์เท่านั้น มาปรับโค้ดให้กระชับยิ่งขึ้นโดยแยกส่วนที่ต่างกันออกมาไว้ในนิพจน์ if และ else เพื่อกำหนดค่าของบรรทัดสถานะและชื่อไฟล์ให้กับตัวแปร จากนั้นเราจะสามารถนำตัวแปรเหล่านั้นมาใช้งานร่วมกันในโค้ดส่วนที่อ่านไฟล์และเขียนการตอบกลับได้โดยตรง ลิสติ้ง 21-9 แสดงผลลัพธ์ของโค้ดหลังจากปรับแทนที่บล็อก if และ else เดิม
use std::{
fs,
io::{BufReader, prelude::*},
net::{TcpListener, TcpStream},
};
fn main() {
let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
for stream in listener.incoming() {
let stream = stream.unwrap();
handle_connection(stream);
}
}
// --snip--
fn handle_connection(mut stream: TcpStream) {
// --snip--
let buf_reader = BufReader::new(&stream);
let request_line = buf_reader.lines().next().unwrap().unwrap();
let (status_line, filename) = if request_line == "GET / HTTP/1.1" {
("HTTP/1.1 200 OK", "hello.html")
} else {
("HTTP/1.1 404 NOT FOUND", "404.html")
};
let contents = fs::read_to_string(filename).unwrap();
let length = contents.len();
let response =
format!("{status_line}\r\nContent-Length: {length}\r\n\r\n{contents}");
stream.write_all(response.as_bytes()).unwrap();
}
ตอนนี้บล็อก if และ else จะคืนค่าเฉพาะคู่ข้อมูลของบรรทัดสถานะและชื่อไฟล์ออกมาเป็นทูเพิล (tuple) จากนั้นเราใช้การแยกโครงสร้าง (destructuring) เพื่อนำค่าทั้งสองมากำหนดให้กับตัวแปร status_line และ filename ผ่านแพตเทิร์นในสเตตเมนต์ let ดังที่เราได้ศึกษาไปในบทที่ 19
โค้ดส่วนที่เคยซ้ำซ้อนกันถูกย้ายออกมาอยู่นอกบล็อก if และ else โดยเรียกใช้ตัวแปร status_line และ filename แทน การทำเช่นนี้ช่วยให้เห็นความแตกต่างระหว่างทั้งสองกรณีได้ชัดเจนยิ่งขึ้น และทำให้มีจุดแก้ไขโค้ดเพียงจุดเดียวหากเราต้องการปรับเปลี่ยนการอ่านไฟล์หรือการเขียนการตอบกลับในอนาคต โดยที่พฤติกรรมการทำงานของโค้ดในลิสติ้ง 21-9 ยังคงเหมือนกับในลิสติ้ง 21-7 ทุกประการ
ยอดเยี่ยมมาก! ตอนนี้เราได้เว็บเซิร์ฟเวอร์เรียบง่ายด้วยโค้ด Rust เพียงราว ๆ 40 บรรทัด ซึ่งสามารถตอบกลับคำขอที่ต้องการด้วยหน้าเว็บที่มีเนื้อหา และตอบกลับคำขออื่น ๆ ทั้งหมดด้วยรหัส 404
อย่างไรก็ตาม เซิร์ฟเวอร์ของเราในปัจจุบันทำงานอยู่บนเธรดเดียว จึงให้บริการคำขอได้ทีละรายการเท่านั้น ในหัวข้อถัดไป เรามาดูกันว่าข้อจำกัดนี้จะส่งผลเสียอย่างไรเมื่อเกิดคำขอที่ใช้เวลาประมวลผลนาน และเราจะแก้ไขปัญหานี้อย่างไรเพื่อให้เซิร์ฟเวอร์สามารถรองรับคำขอหลายรายการพร้อมกันได้