(Bonus) Function improvement

README.md

@@ -47,4 +47,12 @@ Pada tahap ini, kita menyelesaikan masalah *single-thread bottleneck* dengan men
 2. Kita menggunakan struktur komunikasi **Channel** (`mpsc::channel`) di Rust. `ThreadPool` bertindak sebagai pengirim pesan (*Sender*), dan setiap `Worker` berbagi akses sebagai penerima pesan (*Receiver*) melalui `Arc<Mutex<Receiver>>` agar aman dari *race condition* antar *thread*.
 2. Kita menggunakan struktur komunikasi **Channel** (`mpsc::channel`) di Rust. `ThreadPool` bertindak sebagai pengirim pesan (*Sender*), dan setiap `Worker` berbagi akses sebagai penerima pesan (*Receiver*) melalui `Arc<Mutex<Receiver>>` agar aman dari *race condition* antar *thread*.
 3. Setiap kali ada koneksi masuk dari browser, fungsi `main` akan memanggil `pool.execute(...)` dan mengirimkan tugas (closure/pekerjaan yang harus dieksekusi) ke dalam *channel*.
 3. Setiap kali ada koneksi masuk dari browser, fungsi `main` akan memanggil `pool.execute(...)` dan mengirimkan tugas (closure/pekerjaan yang harus dieksekusi) ke dalam *channel*.
 4. *Worker* yang sedang menganggur akan menerima tugas tersebut dari *channel* dan langsung mengeksekusinya. 
 4. *Worker* yang sedang menganggur akan menerima tugas tersebut dari *channel* dan langsung mengeksekusinya. 
-5. Dengan arsitektur ini, jika ada pengguna yang mengakses rute lambat seperti `/sleep`, hanya satu *Worker* yang akan tertidur. Tiga *Worker* lainnya tetap *standby* dan bisa langsung melayani koneksi baru yang masuk secara bersamaan (karena itu tes membuka 2 window secara bersamaan sekarang berhasil tanpa harus antre).
+5. Dengan arsitektur ini, jika ada pengguna yang mengakses rute lambat seperti `/sleep`, hanya satu *Worker* yang akan tertidur. Tiga *Worker* lainnya tetap *standby* dan bisa langsung melayani koneksi baru yang masuk secara bersamaan (karena itu tes membuka 2 window secara bersamaan sekarang berhasil tanpa harus antre).
\ No newline at end of file
+
+# Commit Bonus Reflection notes
+
+Pada bagian bonus ini, saya mengganti fungsi `new` pada `ThreadPool` menjadi fungsi `build`. Berikut adalah perbandingan dan alasan perubahannya:
+
+1. **Fungsi `new` (Sebelumnya):** Di Rust, fungsi `new` memiliki conventional yang tidak tertulis, bahwa ia harus **selalu berhasil** membuat dan mengembalikan *instance* dari sebuah struct. Pada kode sebelumnya, jika kita memasukkan parameter `size` bernilai `0`, program akan memanggil makro `assert!` dan seketika mengalami crash. Hal ini bukanlah *design pattern* yang baik untuk sebuah *library* atau public API, karena dapat mematikan program utama pengguna secara paksa.
+2. **Fungsi `build` (Perbaikan):** Ketika proses pembuatan *instance* memiliki kemungkinan gagal (misalnya karena validasi *input* yang salah seperti `size == 0`), lebih *idiomatic* di Rust untuk menggunakan fungsi bernama `build` yang mengembalikan tipe data `Result`. Dengan cara ini, jika input bernilai `0`, kita mengembalikan `Err(PoolCreationError)` alih-alih melakukan *panic*.
+3. **Dampak:** Penggunaan `build` memberikan fleksibilitas kepada pemanggil (dalam hal ini `main.rs`) untuk menangani *error* tersebut dengan elegan (misalnya dengan mencetak pesan *error* ke *stderr* dan keluar menggunakan `std::process::exit(1)`), membuat server menjadi jauh lebih *robust* dan aman dari *crash* mendadak.
\ No newline at end of file

src/lib.rs

-use std::{ sync::{ mpsc, Arc, Mutex }, thread };
+use std::{ fmt, sync::{ mpsc, Arc, Mutex }, thread };
+
+// custom error untuk ThreadPool
+#[derive(Debug)]
+pub struct PoolCreationError;
+
+impl fmt::Display for PoolCreationError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "ThreadPool size must be greater than zero.")
+    }
+}
 
 
 pub struct ThreadPool {
 pub struct ThreadPool {
     workers: Vec<Worker>,
     workers: Vec<Worker>,
@@ -8,15 +18,12 @@ pub struct ThreadPool {
 type Job = Box<dyn FnOnce() + Send + 'static>;
 type Job = Box<dyn FnOnce() + Send + 'static>;
 
 
 impl ThreadPool {
 impl ThreadPool {
-    /// Create a new ThreadPool.
-    ///
-    /// The size is the number of threads in the pool.
-    ///
-    /// # Panics
-    ///
-    /// The `new` function will panic if the size is zero.
-    pub fn new(size: usize) -> ThreadPool {
-        assert!(size > 0);
+    /// Create a ThreadPool using build.
+    /// Returns a Result instead of panicking on zero size.
+    pub fn build(size: usize) -> Result<ThreadPool, PoolCreationError> {
+        if size == 0 {
+            return Err(PoolCreationError);
+        }
 
 
         let (sender, receiver) = mpsc::channel();
         let (sender, receiver) = mpsc::channel();
         let receiver = Arc::new(Mutex::new(receiver));
         let receiver = Arc::new(Mutex::new(receiver));
@@ -27,7 +34,7 @@ impl ThreadPool {
             workers.push(Worker::new(id, Arc::clone(&receiver)));
             workers.push(Worker::new(id, Arc::clone(&receiver)));
         }
         }
 
 
-        ThreadPool { workers, sender }
+        Ok(ThreadPool { workers, sender })
     }
     }
 
 
     pub fn execute<F>(&self, f: F) where F: FnOnce() + Send + 'static {
     pub fn execute<F>(&self, f: F) where F: FnOnce() + Send + 'static {
@@ -46,7 +53,7 @@ impl Worker {
         let thread = thread::spawn(move || {
         let thread = thread::spawn(move || {
             loop {
             loop {
                 let job = receiver.lock().unwrap().recv().unwrap();
                 let job = receiver.lock().unwrap().recv().unwrap();
-                println!("Worker {id} got a job; executing.");
+                // println!("Worker {id} got a job; executing."); // ga terlalu butuh
                 job();
                 job();
             }
             }
         });
         });

src/main.rs

-use hello::ThreadPool; // ambil ThreadPool dari src/lib.rs (template code orang btw)
+use hello::ThreadPool; // ambil ThreadPool dari src/lib.rs (template code orang btw, dgn sedikit modifikasi)
 use std::{
 use std::{
     fs,
     fs,
     io::{ prelude::*, BufReader },
     io::{ prelude::*, BufReader },
@@ -9,7 +9,12 @@ use std::{
 
 
 fn main() {
 fn main() {
     let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
     let listener = TcpListener::bind("127.0.0.1:7878").unwrap();
-    let pool = ThreadPool::new(4); // set 4 thread
+
+    // pakai build dan handling error
+    let pool = ThreadPool::build(4).unwrap_or_else(|err| {
+        eprintln!("Problem creating ThreadPool: {err}");
+        std::process::exit(1);
+    });
 
 
     for stream in listener.incoming() {
     for stream in listener.incoming() {
         let stream = stream.unwrap();
         let stream = stream.unwrap();