From d7dd730a88a94de3a550d40a4c7150141f670a27 Mon Sep 17 00:00:00 2001 From: Jolimaitre Matthieu Date: Fri, 12 Nov 2021 22:22:41 +0100 Subject: [PATCH] implemented logging for main components --- src/lib/config.rs | 2 +- src/lib/db/mod.rs | 40 +++++++++++++++++++++++++++++++++++----- src/lib/harsh.rs | 7 ++++--- src/lib/http/mod.rs | 39 +++++++++++++++++++++++++++++---------- src/lib/log.rs | 42 +++++++++++++++++++++++++++++++++--------- src/main.rs | 1 - 6 files changed, 102 insertions(+), 29 deletions(-) diff --git a/src/lib/config.rs b/src/lib/config.rs index ad5f444..21a1a89 100644 --- a/src/lib/config.rs +++ b/src/lib/config.rs @@ -47,7 +47,7 @@ impl Configuration { fn write_config(data: &Self) { let serialized = ron::to_string(data).unwrap(); - write(CONFIG_PATHS[0], serialized); + write(CONFIG_PATHS[0], serialized).unwrap_or_else(|_| ()); } } diff --git a/src/lib/db/mod.rs b/src/lib/db/mod.rs index 6baa80c..9e3a6a5 100644 --- a/src/lib/db/mod.rs +++ b/src/lib/db/mod.rs @@ -2,19 +2,49 @@ pub mod models; use sled::Db; -use super::{config::Configuration, harsh::Error}; +use super::{ + config::Configuration, + harsh::Error, + log::{Loggable, Logger}, +}; /// /// handle the database access /// pub struct DbManager { - handle: Db, + path: String, + handle: Option, + logger: Logger, } impl DbManager { /// constructor - pub fn new(config: Configuration) -> Result { - let handle = sled::open(config.database_path)?; - Ok(DbManager { handle }) + pub fn new(config: Configuration, logger: Logger) -> Result { + let mut result = DbManager { + path: config.database_path, + handle: None, + logger, + }; + result.info("ininitalized new manager"); + + result.open_db()?; + result.info("openned database"); + Ok(result) + } + + pub fn open_db(&mut self) -> Result<(), Error> { + let handle = sled::open(&self.path)?; + self.handle = Some(handle); + Ok(()) + } +} + +impl Loggable for DbManager { + fn name(&self) -> String { + "db manager".to_string() + } + + fn logger(&self) -> Logger { + self.logger.clone() } } diff --git a/src/lib/harsh.rs b/src/lib/harsh.rs index 6c0e8fd..bebf40a 100644 --- a/src/lib/harsh.rs +++ b/src/lib/harsh.rs @@ -22,10 +22,10 @@ pub struct Harsh { impl Harsh { pub fn new(configuration: Configuration) -> Self { - let db_manager = - DbManager::new(configuration.clone()).expect("failed to open / create the database"); let logger = Logger::new(configuration.clone()); - let shared_state = State::new_shared(db_manager, logger); + let db_manager = DbManager::new(configuration.clone(), logger.clone()) + .expect("failed to open / create database"); + let shared_state = State::new_shared(db_manager, logger.clone()); let http_manager = HttpManager::new(configuration.clone(), shared_state.clone()); Harsh { @@ -49,6 +49,7 @@ pub struct State { impl State { pub fn new_shared(db_manager: DbManager, logger: Logger) -> SharedState { + logger.info("initialized shared state"); let state = State { db_manager: RwLock::new(db_manager), logger: RwLock::new(logger), diff --git a/src/lib/http/mod.rs b/src/lib/http/mod.rs index 140a766..20c2469 100644 --- a/src/lib/http/mod.rs +++ b/src/lib/http/mod.rs @@ -14,32 +14,51 @@ use self::routes::setup_routes; use super::config::Configuration; use super::harsh::SharedState; +use super::log::Loggable; +use super::log::Logger; /// /// listen for incoming requests and handle both incoming and outgoing requests /// pub struct HttpManager { - _shared_state: SharedState, + shared_state: SharedState, + port: u32, app: Router, + logger: Logger, } impl HttpManager { /// constructor - pub fn new(_config: Configuration, shared_state: SharedState) -> Self { + pub fn new(config: Configuration, shared_state: SharedState) -> Self { let app = setup_routes(Router::new()).layer(AddExtensionLayer::new(shared_state.clone())); + let logger = shared_state.logger.try_read().unwrap().clone(); - HttpManager { - _shared_state: shared_state.clone(), + let result = HttpManager { + shared_state: shared_state.clone(), + port: config.port, app, - } + logger, + }; + result.info("initialized new manager"); + + result } /// listen for and handle received requests pub async fn serve(self) { - let address = "0.0.0.0:3000".parse().unwrap(); - axum::Server::bind(&address) - .serve(self.app.into_make_service()) - .await - .unwrap(); + let address = format!("0.0.0.0:{}", self.port).parse().unwrap(); + self.info(format!("listening to address '{}'", address)); + let server = axum::Server::bind(&address).serve(self.app.into_make_service()); + server.await.unwrap(); + } +} + +impl Loggable for HttpManager { + fn name(&self) -> String { + "http manager".to_string() + } + + fn logger(&self) -> Logger { + self.logger.clone() } } diff --git a/src/lib/log.rs b/src/lib/log.rs index f6253e9..31891df 100644 --- a/src/lib/log.rs +++ b/src/lib/log.rs @@ -1,3 +1,5 @@ +use std::{borrow::Borrow, ops::Deref}; + use super::config::Configuration; use chrono::prelude::*; use colored::Colorize; @@ -5,6 +7,7 @@ use colored::Colorize; /// /// configurable structure with methods to log informations in different ways /// +#[derive(Clone)] pub struct Logger { // } @@ -15,19 +18,16 @@ impl Logger { Logger {} } - pub fn info(&self, msg: String) { - let tag_section = "[info]".blue(); - println!("{} {} {}", time_segment(), tag_section, msg); + pub fn info>(&self, msg: T) { + println!("{} {} {}", time_segment(), "[info]".blue(), msg.into()); } - pub fn warn(&self, msg: String) { - let tag_section = "[warn]".yellow(); - println!("{} {} {}", time_segment(), tag_section, msg); + pub fn warn>(&self, msg: T) { + println!("{} {} {}", time_segment(), "[warn]".yellow(), msg.into()); } - pub fn fail(&self, msg: String) { - let tag_section = "[fail]".red(); - println!("{} {} {}", time_segment(), tag_section, msg); + pub fn fail>(&self, msg: T) { + println!("{} {} {}", time_segment(), "[fail]".red(), msg.into()); } } @@ -37,3 +37,27 @@ fn time_segment() -> String { let result = now.format("[%Y.%m.%d-%H:%M:%S]").to_string(); result } + +pub trait Loggable { + fn name(&self) -> String; + + fn logger(&self) -> Logger; + + fn info>(&self, msg: T) { + self.logger().info(self.format_message(msg)); + } + + fn warn>(&self, msg: T) { + self.logger().warn(self.format_message(msg)); + } + + fn fail>(&self, msg: T) { + self.logger().fail(self.format_message(msg)); + } + + fn format_message>(&self, msg: T) -> String { + let message: String = msg.into(); + let formatted = format!("[{}] {}", self.name(), message); + formatted + } +} diff --git a/src/main.rs b/src/main.rs index 6b3a094..4c05023 100644 --- a/src/main.rs +++ b/src/main.rs @@ -5,6 +5,5 @@ pub mod lib; #[tokio::main] pub async fn main() { - println!("Hello, harmony!"); lib::harsh::main().await; }