reorganize debug events

README.md

@@ -41,12 +41,8 @@ nexy -p /path/to/public_dir
 
         [default: 127.0.0.1:1900 [::1]:1900]
 
--d, --debug <DEBUG>
+-d, --debug
-        Debug level
+        Print debug information
-
-        * `e` - error * `i` - info
-
-        [default: ei]
 
 -p, --public <PUBLIC>
         Absolute path to the public files directory

src/config.rs

@@ -20,12 +20,9 @@ pub struct Config {
     ])]
     pub bind: Vec<String>,
 
-    /// Debug level
+    /// Print debug information
-    ///
+    #[arg(short, long, default_value_t = false)]
-    /// * `e` - error
+    pub debug: bool,
-    /// * `i` - info
-    #[arg(short, long, default_value_t = String::from("ei"))]
-    pub debug: String,
 
     /// Absolute path to the public files directory
     #[arg(short, long)]

src/main.rs

@@ -5,10 +5,10 @@ mod session;
 
 fn main() -> anyhow::Result<()> {
     use clap::Parser;
-    let a = config::Config::parse();
+    let c = config::Config::parse();
-    let s = std::sync::Arc::new(session::Session::init(&a)?);
+    let s = std::sync::Arc::new(session::Session::init(&c)?);
-    for b in a.bind {
+    for b in c.bind {
-        s.debug.info(&format!("start server on `{b}`..."));
+        println!("start server on `{b}`...");
         match std::net::TcpListener::bind(&b) {
             Ok(r) => {
                 std::thread::spawn({
@@ -16,9 +16,7 @@ fn main() -> anyhow::Result<()> {
                     move || server::start(r, &s)
                 });
             }
-            Err(e) => s
+            Err(e) => eprintln!("failed to start server on `{b}`: `{e}`"),
-                .debug
-                .error(&format!("failed to start server on `{b}`: `{e}`")),
         }
     }
     std::thread::park();

src/response.rs

@@ -1,9 +1,9 @@
-/// Internal types
+/// Internal server response types
 pub enum Response<'a> {
     /// Includes reference to the original request
     AccessDenied(&'a str),
-    /// Includes server-side error description
+    /// Includes query + server-side error description
-    InternalServerError(String),
+    InternalServerError(&'a str, String),
     /// Includes reference to the original request
     NotFound(&'a str),
     /// Includes bytes array

src/server.rs

@@ -12,15 +12,11 @@ pub fn start(server: TcpListener, session: &Arc<Session>) {
                     let session = session.clone();
                     move || match Connection::init(&session, stream) {
                         Ok(connection) => connection.handle(),
-                        Err(e) => session
+                        Err(e) => eprintln!("failed to init connection: `{e}`"),
-                            .debug
-                            .error(&format!("failed to init connection: `{e}`")),
                     }
                 });
             }
-            Err(e) => session
+            Err(e) => eprintln!("failed to accept incoming connection: `{e}`"),
-                .debug
-                .error(&format!("failed to accept incoming connection: `{e}`")),
         }
     }
 }

src/server/connection.rs

@@ -35,10 +35,12 @@ impl Connection {
         let mut t = 0; // total bytes
         match self.request() {
             Ok(q) => {
-                self.session.debug.info(&format!(
+                if self.session.is_debug {
-                    "[{}] < [{}] request `{q}`...",
+                    println!(
-                    self.address.server, self.address.client
+                        "[{}] < [{}] request `{q}`...",
-                ));
+                        self.address.server, self.address.client
+                    )
+                }
                 if let Some(ref i) = self.session.request {
                     i.add(&self.address.client, &q)
                 }
@@ -51,10 +53,13 @@ impl Connection {
                     .clf(&self.address.client, Some(&q), 0, t);
             }
             Err(e) => {
-                t += self.response(Response::InternalServerError(format!(
+                t += self.response(Response::InternalServerError(
-                    "[{}] < [{}] failed to handle incoming request: `{e}`",
+                    "",
-                    self.address.server, self.address.client
+                    format!(
-                )));
+                        "[{}] < [{}] failed to handle incoming request: `{e}`",
+                        self.address.server, self.address.client
+                    ),
+                ));
                 self.session
                     .access_log
                     .clf(&self.address.client, None, 1, t);
@@ -87,50 +92,61 @@ impl Connection {
                     )
                 }
             }
-            Response::InternalServerError(e) => {
+            Response::InternalServerError(q, e) => {
-                self.session.debug.error(&e);
+                eprintln!(
+                    "[{}] > [{}] `{q}`: internal server error: `{e}`",
+                    self.address.server, self.address.client
+                );
                 self.session.template.internal_server_error()
             }
             Response::AccessDenied(q) => {
-                self.session.debug.error(&format!(
+                eprintln!(
                     "[{}] < [{}] access to `{q}` denied.",
                     self.address.server, self.address.client
-                ));
+                );
                 self.session.template.access_denied()
             }
             Response::NotFound(q) => {
-                self.session.debug.error(&format!(
+                eprintln!(
                     "[{}] < [{}] requested resource `{q}` not found.",
                     self.address.server, self.address.client
-                ));
+                );
                 self.session.template.not_found()
             }
         };
         match self.stream.write_all(bytes) {
-            Ok(()) => self.session.debug.info(&format!(
+            Ok(()) => {
-                "[{}] > [{}] sent {} bytes response.",
+                if self.session.is_debug {
-                self.address.server,
+                    println!(
-                self.address.client,
+                        "[{}] > [{}] sent {} bytes response.",
-                bytes.len()
+                        self.address.server,
-            )),
+                        self.address.client,
-            Err(e) => self.session.debug.error(&format!(
+                        bytes.len()
+                    )
+                }
+            }
+            Err(e) => eprintln!(
                 "[{}] ! [{}] failed to response: `{e}`",
                 self.address.server, self.address.client,
-            )),
+            ),
         };
         bytes.len()
     }
 
     fn shutdown(self) {
         match self.stream.shutdown(std::net::Shutdown::Both) {
-            Ok(()) => self.session.debug.info(&format!(
+            Ok(()) => {
-                "[{}] - [{}] connection closed by server.",
+                if self.session.is_debug {
-                self.address.server, self.address.client,
+                    println!(
-            )),
+                        "[{}] - [{}] connection closed by server.",
-            Err(e) => self.session.debug.error(&format!(
+                        self.address.server, self.address.client,
+                    )
+                }
+            }
+            Err(e) => eprintln!(
                 "[{}] > [{}] failed to close connection: `{e}`",
                 self.address.server, self.address.client,
-            )),
+            ),
         }
     }
 }

src/session.rs

@@ -1,18 +1,17 @@
 mod access_log;
-mod debug;
 mod public;
 mod request;
 mod template;
 
-use {access_log::AccessLog, debug::Debug, public::Public, request::Request, template::Template};
+use {access_log::AccessLog, public::Public, request::Request, template::Template};
 
 /// Shared, multi-thread features for the current server session
 pub struct Session {
     pub access_log: AccessLog,
-    pub debug: Debug,
     pub public: Public,
     pub request: Option<Request>,
     pub template: Template,
+    pub is_debug: bool,
 }
 
 impl Session {
@@ -20,7 +19,6 @@ impl Session {
         let template = Template::init(config)?;
         Ok(Self {
             access_log: AccessLog::init(config)?,
-            debug: Debug::init(config)?,
             public: Public::init(config)?,
             request: if template.welcome.contains("{hosts}")
                 || template.welcome.contains("{hits}")
@@ -32,6 +30,7 @@ impl Session {
                 None // do not int request collector if its features not in use
             },
             template,
+            is_debug: config.debug,
         })
     }
 }

src/session/debug.rs

@@ -1,30 +0,0 @@
-mod level;
-use level::Level;
-
-pub struct Debug(Vec<Level>);
-
-impl Debug {
-    pub fn init(config: &crate::config::Config) -> anyhow::Result<Self> {
-        let mut l = Vec::with_capacity(config.debug.len());
-        for s in config.debug.to_lowercase().chars() {
-            l.push(Level::parse(s)?);
-        }
-        Ok(Self(l))
-    }
-
-    pub fn error(&self, message: &str) {
-        if self.0.contains(&Level::Error) {
-            eprintln!("[{}] [error] {message}", now());
-        }
-    }
-
-    pub fn info(&self, message: &str) {
-        if self.0.contains(&Level::Info) {
-            println!("[{}] [info] {message}", now());
-        }
-    }
-}
-
-fn now() -> String {
-    chrono::Local::now().to_rfc3339()
-}

src/session/debug/level.rs

@@ -1,17 +0,0 @@
-use anyhow::{Result, bail};
-
-#[derive(PartialEq)]
-pub enum Level {
-    Error,
-    Info,
-}
-
-impl Level {
-    pub fn parse(value: char) -> Result<Self> {
-        match value {
-            'e' => Ok(Self::Error),
-            'i' => Ok(Self::Info),
-            _ => bail!("unsupported debug level `{value}`!"),
-        }
-    }
-}

src/session/public.rs

@@ -61,7 +61,7 @@ impl Public {
             Ok(t) => match (t.is_dir(), t.is_file()) {
                 (true, _) => callback(match self.list(&p) {
                     Ok(list) => Response::Directory(query, list, p == self.public_dir),
-                    Err(e) => Response::InternalServerError(e.to_string()),
+                    Err(e) => Response::InternalServerError(query, e.to_string()),
                 }),
                 (_, true) => match fs::File::open(p) {
                     Ok(mut f) => loop {
@@ -70,21 +70,24 @@ impl Public {
                             Ok(0) => break,
                             Ok(n) => callback(Response::File(&b[..n])),
                             Err(e) => {
-                                return callback(Response::InternalServerError(format!(
+                                return callback(Response::InternalServerError(
-                                    "failed to read response chunk for `{query}`: `{e}`"
+                                    query,
-                                )));
+                                    format!("failed to read response chunk: `{e}`"),
+                                ));
                             }
                         }
                     },
-                    Err(e) => callback(Response::InternalServerError(format!(
+                    Err(e) => callback(Response::InternalServerError(
-                        "failed to read response for query`{query}`: `{e}`"
+                        query,
-                    ))),
+                        format!("failed to read response: `{e}`"),
+                    )),
                 },
                 _ => panic!(), // unexpected
             },
-            Err(e) => callback(Response::InternalServerError(format!(
+            Err(e) => callback(Response::InternalServerError(
-                "failed to read storage for `{query}`: `{e}`"
+                query,
-            ))),
+                format!("failed to read storage: `{e}`"),
+            )),
         }
     }