From 889ed37f80eb05692684fdf719d7eb1bdcd1a8c3 Mon Sep 17 00:00:00 2001
From: Jett Chen <jettchen12345@gmail.com>
Date: Sun, 17 Dec 2023 17:59:37 +0800
Subject: [PATCH] Update logging

---
 burrow/src/daemon/instance.rs  |  1 -
 burrow/src/daemon/net/apple.rs |  8 +++-----
 burrow/src/wireguard/iface.rs  | 22 +++++++++-------------
 3 files changed, 12 insertions(+), 19 deletions(-)

diff --git a/burrow/src/daemon/instance.rs b/burrow/src/daemon/instance.rs
index 7866fb5..8c96b98 100644
--- a/burrow/src/daemon/instance.rs
+++ b/burrow/src/daemon/instance.rs
@@ -111,7 +111,6 @@ impl DaemonInstance {
     }
 
     pub async fn run(&mut self) -> Result<()> {
-        tracing::info!("BEGIN");
         while let Ok(command) = self.rx.recv().await {
             let response = self.proc_command(command).await;
             info!("Daemon response: {:?}", response);
diff --git a/burrow/src/daemon/net/apple.rs b/burrow/src/daemon/net/apple.rs
index b84ec08..a999d0f 100644
--- a/burrow/src/daemon/net/apple.rs
+++ b/burrow/src/daemon/net/apple.rs
@@ -7,7 +7,7 @@ use crate::daemon::{daemon_main, DaemonClient};
 
 #[no_mangle]
 pub extern "C" fn start_srv() {
-    info!("Rust: Starting server");
+    info!("Starting server");
     let _handle = thread::spawn(move || {
         let rt = Runtime::new().unwrap();
         rt.block_on(async {
@@ -20,10 +20,8 @@ pub extern "C" fn start_srv() {
     rt.block_on(async {
         loop {
             match DaemonClient::new().await {
-                Ok(_) => break,
-                Err(_e) => {
-                    // error!("Error when connecting to daemon: {}", e)
-                }
+                Ok(..) => info!("Server successfully started"),
+                Err(e) => error!("Could not connect to server: {}", e)
             }
         }
     });
diff --git a/burrow/src/wireguard/iface.rs b/burrow/src/wireguard/iface.rs
index a23545b..897dac1 100755
--- a/burrow/src/wireguard/iface.rs
+++ b/burrow/src/wireguard/iface.rs
@@ -90,56 +90,52 @@ impl Interface {
     }
 
     pub async fn run(&self) -> anyhow::Result<()> {
-        debug!("RUN: starting interface");
         let pcbs = self.pcbs.clone();
         let tun = self
             .tun
             .clone()
             .ok_or(anyhow::anyhow!("tun interface does not exist"))?;
-        log::info!("starting interface");
+        log::info!("Starting interface");
 
         let outgoing = async move {
             loop {
-                // tracing::debug!("starting loop...");
                 let mut buf = [0u8; 3000];
 
                 let src = {
                     let src = match tun.read().await.recv(&mut buf[..]).await {
                         Ok(len) => &buf[..len],
                         Err(e) => {
-                            error!("failed to read from interface: {}", e);
+                            error!("Failed to read from interface: {}", e);
                             continue;
                         }
                     };
-                    debug!("read {} bytes from interface", src.len());
-                    debug!("bytes: {:?}", src);
+                    debug!("Read {} bytes from interface", src.len());
                     src
                 };
 
                 let dst_addr = match Tunnel::dst_address(src) {
                     Some(addr) => addr,
                     None => {
-                        tracing::debug!("no destination found");
+                        debug!("No destination found");
                         continue;
                     }
                 };
 
-                tracing::debug!("dst_addr: {}", dst_addr);
-                debug!("src_addr: {}", Tunnel::src_address(src).unwrap());
+                debug!("Routing packet to {}", dst_addr);
 
                 let Some(idx) = pcbs.find(dst_addr) else {
                     continue
                 };
 
-                tracing::debug!("found peer:{}", idx);
+                debug!("Found peer:{}", idx);
 
                 match pcbs.pcbs[idx].send(src).await {
                     Ok(..) => {
                         let addr = pcbs.pcbs[idx].endpoint;
-                        tracing::debug!("sent packet to peer {}", addr);
+                        debug!("Sent packet to peer {}", addr);
                     }
                     Err(e) => {
-                        log::error!("failed to send packet {}", e);
+                        log::error!("Failed to send packet {}", e);
                         continue;
                     }
                 };
@@ -171,7 +167,7 @@ impl Interface {
                         log::error!("failed to run pcb: {}", e);
                         return;
                     } else {
-                        tracing::debug!("pcb ran successfully");
+                        debug!("pcb ran successfully");
                     }
                 };
                 debug!("task made..");