Logging

Cargo.toml

@@ -6,6 +6,8 @@ description = "BitTorrent client written in Rust"
 
 [dependencies]
 anyhow = "1.0.75"
+env_logger = "0.10.0"
+log = "0.4.20"
 rand = "0.8.5"
 reqwest = { version = "0.11", features=["blocking"] }
 sha1 = "0.10.6"

src/bencode.rs

@@ -84,7 +84,7 @@ pub fn parse_bencoded(bencoded: ByteString) -> (Option<BencodeValue>, ByteString
         'l' => parse_list(bencoded),
         'd' => parse_dict(bencoded),
         _ => {
-            eprintln!("unexpected character `{}`", *next as char);
+            error!("unexpected character `{}`", *next as char);
             (None, bencoded)
         }
     }

src/main.rs

@@ -1,3 +1,6 @@
+#[macro_use]
+extern crate log;
+
 use peer::handshake;
 use rand::{distributions::Alphanumeric, thread_rng, Rng};
 use std::{fs, path::PathBuf};
@@ -19,25 +22,27 @@ mod tracker;
 mod types;
 
 fn main() {
+    env_logger::init();
+
     let path = PathBuf::from("data/knoppix.torrent");
     let bencoded = fs::read(path).unwrap();
     let metainfo_dict = match parse_bencoded(bencoded) {
         (Some(metadata), left) if left.is_empty() => metadata,
         _ => panic!("metadata file parsing error"),
     };
-    println!("metainfo dict: {metainfo_dict:?}");
+    debug!("metainfo dict: {metainfo_dict:?}");
     let metainfo = match Metainfo::try_from(metainfo_dict.clone()) {
         Ok(info) => info,
         Err(e) => panic!("metadata file structure error: {e}"),
     };
-    println!("metainfo: {metainfo:?}");
+    info!("metainfo: {metainfo:?}");
     let info_dict_str = match metainfo_dict {
         bencode::BencodeValue::Dict(d) => d.get("info").unwrap().encode(),
         _ => unreachable!(),
     };
     let info_hash = sha1::encode(info_dict_str);
     let peer_id = generate_peer_id();
-    println!("peer id {}", String::from_utf8_lossy(peer_id.as_slice()));
+    info!("peer id {}", String::from_utf8_lossy(peer_id.as_slice()));
     let tracker_response = tracker_request(
         metainfo.announce,
         TrackerRequest::new(
@@ -48,12 +53,12 @@ fn main() {
         ),
     )
     .expect("request failed");
-    println!("tracker response: {tracker_response:?}");
+    info!("tracker response: {tracker_response:?}");
     if let TrackerResponse::Success(resp) = tracker_response {
         for p in resp.peers {
             match handshake(&p, &info_hash, &peer_id) {
-                Ok(_) => println!("successfull handshake with peer {:?}", p),
-                Err(e) => eprintln!("handshake error: {}", e),
+                Ok(_) => info!("successfull handshake with peer {:?}", p),
+                Err(e) => warn!("handshake error: {}", e),
             }
         }
     }

src/peer.rs

@@ -57,7 +57,7 @@ pub fn handshake(
     peer_id: &ByteString,
 ) -> Result<TcpStream> {
     let timeout = Duration::new(4, 0);
-    println!("connecting to peer {peer:?}");
+    debug!("connecting to peer {peer:?}");
     let mut stream = TcpStream::connect_timeout(
         &SocketAddr::new(IpAddr::from_str(&peer.ip).unwrap(), peer.port as u16),
         timeout,
@@ -70,22 +70,22 @@ pub fn handshake(
     }
     .into();
 
-    println!("writing handshake {}", hex(&handshake.to_vec()));
+    debug!("writing handshake {}", hex(&handshake.to_vec()));
     stream.write_all(&handshake).context("write error")?;
     stream.flush()?;
 
     let mut reader = BufReader::new(&stream);
     let mut read_packet = [0; 68];
-    println!("reading handshake");
+    debug!("reading handshake");
     reader.read_exact(&mut read_packet).context("read error")?;
     let msg: Vec<u8> = read_packet.to_vec();
-    println!("peer response: {}", hex(&msg));
+    debug!("peer response: {}", hex(&msg));
     let hp = HandshakePacket::try_from(msg)
         .map_err(Error::msg)
         .context("handshake parse error")?;
     ensure!(hp.info_hash == *info_hash, "response `info_hash` differ");
     if hp.peer_id != peer.peer_id {
-        println!("peer id differ")
+        debug!("peer id differ")
     }
     Ok(stream)
 }

src/tracker.rs

@@ -213,17 +213,17 @@ pub fn tracker_request(
             .join("&")
     );
     let url = format!("{announce}{params}");
-    println!("url: {url}");
+    debug!("url: {url}");
     let resp = Client::new()
         .get(url)
         .send()
         .map_err(|e| format!("request error: {}", e))?
         .bytes()
         .map_err(|e| format!("request body error: {}", e))?;
-    println!("raw response: {}", String::from_utf8_lossy(&resp));
+    debug!("raw response: {}", String::from_utf8_lossy(&resp));
     let resp_dict = parse_bencoded(resp.to_vec())
         .0
         .ok_or("Malformed response")?;
-    println!("response: {resp_dict:?}");
+    debug!("response: {resp_dict:?}");
     TrackerResponse::try_from(resp_dict)
 }