feat: Added logging setting

Author: Andcool-Systems

Cargo.toml

@@ -2,6 +2,8 @@
 name = "mc-oauth"
 version = "0.1.9"
 edition = "2021"
+authors = ["AndcoolSystems"]
+license = "MIT"
 
 [dependencies]
 tokio = { version = "1.43.0", features = ["full"] }

README.md

@@ -64,6 +64,11 @@ After the project is fully built, the binary file for your OS will be available
 For the server to work, create a `config.toml` file in the same directory as the executable with the following contents:
 
 ```toml
+[global]
+# Server logging level. Possible values:
+# debug, info, warn, error, trace
+logging_level = "info"
+
 [api]
 # API address
 addr = "0.0.0.0"

config.example.toml

@@ -1,31 +1,85 @@
+[global]
+# Server logging level. Possible values:
+# debug, info, warn, error, trace
+logging_level = "info"
+
 [api]
+# API address
 addr = "0.0.0.0"
+
+# API port
 port = 8008
+
+# Life time of assigned code
 code_life_time = 300
+
+# Length of generated code
 code_length = 6
 
 [server]
+# Minecraft server address
 addr = "0.0.0.0"
+
+# Minecraft server port
 port = 25565
-timeout = 20
-server_ip = "localhost" # Change or remove before production use!
-support_1_19 = false # READ: https://github.com/Andcool-Systems/mc-oauth-rs/issues/1
+
+# Server connection timeout
+# Sets the maximum time a client can stay connected to the server. Used to prevent idle or junk connections.
+timeout = 10
+
+# [Optional] This parameter defines the server host to which the clients connect.
+# This is necessary to prevent proxy bypass or spoofing.
+server_ip = "localhost"
+
+# Enable partial support of 1.19-1.19.2 clients
+# https://github.com/Andcool-Systems/mc-oauth-rs/issues/1
+support_1_19 = false
 
 [server.config]
+# Minecraft server name (used for internal auth; can be empty)
 server_name = "mc-oauth-rs"
+
+# Protocol version (`0` for auto)
+# If set to 0, the protocol version that the client uses will be applied.
 protocol = 0
+
+# Minecraft version string (In fact, it's just a stub)
 version = "1.21"
+
+# Session Auth URL  
+# `{{NAME}}` in string will be replaced by the client nickname  
+# `{{HASH}}` will be replaced by the generated client hash
 auth_url = "https://sessionserver.mojang.com/session/minecraft/hasJoined?username={{NAME}}&serverId={{HASH}}"
 
 [server.status]
+# Server description (you can use MOTD)
 description = "§6mc-oauth.andcool.ru"
+
+# Max players count, displayed in server list
 players_max = 0
+
+# Online players count, displayed in server list
 players_online = 0
+
+# Path to the server icon (can be empty)
+# Should be in .png format and 64x64 pixels in size
 icon_path = "server_icon.png"
 
 [messages]
+# Message for successful auth  
+# `{{NAME}}` will be replaced by the client nickname  
+# `{{UUID}}` will be replaced by the client UUID  
+# `{{CODE}}` will be replaced by the generated code
 success = "Hello, §6{{NAME}}§r! Your code is: §a{{CODE}}"
+
+# Message for Mojang API error
 bad_session = "§cFailed to login: Invalid session (Try restarting your game and the launcher)"
+
+# Message for bad server address (`server_ip` setting)
 using_proxy = "§cYou are using a proxy!"
+
+# Message for internal server error
 internal_error = "§cSorry, internal server error occurred"
+
+# Message for unsupported client version
 unsupported_client_version = "§cYou are using unsupported version of client!"

src/config/types.rs

@@ -2,6 +2,9 @@ use serde::Deserialize;
 
 #[derive(Deserialize, Debug)]
 pub struct Config {
+    /// Global APP config
+    pub global: GlobalConfig,
+
     /// API config
     pub api: API,
 
@@ -16,6 +19,12 @@ pub struct Config {
     pub image: Option<String>,
 }
 
+#[derive(Deserialize, Debug)]
+pub struct GlobalConfig {
+    /// Logging level
+    pub logging_level: String,
+}
+
 #[derive(Deserialize, Debug)]
 pub struct API {
     /// API address

src/logging.rs

@@ -0,0 +1,52 @@
+use tracing::{subscriber::set_global_default, Level};
+use tracing_subscriber::{
+    filter::LevelFilter,
+    fmt::format::{Compact, DefaultFields, Format},
+    prelude::*,
+    reload::{self, Handle},
+    FmtSubscriber,
+};
+
+type ReloadHandle = Handle<LevelFilter, FmtSubscriber<DefaultFields, Format<Compact, ()>>>;
+
+/**
+Init logger with provided level
+*/
+pub fn init_logger(initial_level: Level) -> ReloadHandle {
+    let filter = LevelFilter::from_level(initial_level);
+    let (filter_layer, reload_handle) = reload::Layer::new(filter);
+
+    let subscriber = FmtSubscriber::builder()
+        .with_max_level(Level::TRACE)
+        .compact()
+        .without_time()
+        .finish()
+        .with(filter_layer);
+
+    set_global_default(subscriber).expect("Failed to set global default subscriber");
+
+    reload_handle
+}
+
+/**
+Set logging level for existing logger
+*/
+pub fn set_log_level(handle: ReloadHandle, level: tracing::Level) {
+    handle
+        .modify(|filter| *filter = LevelFilter::from_level(level))
+        .expect("Failed to change log level");
+}
+
+/**
+Get log level from string
+*/
+pub fn str_to_log_level(level: &str) -> Option<Level> {
+    match level.to_lowercase().as_str() {
+        "trace" => Some(Level::TRACE),
+        "debug" => Some(Level::DEBUG),
+        "info" => Some(Level::INFO),
+        "warn" => Some(Level::WARN),
+        "error" => Some(Level::ERROR),
+        _ => None,
+    }
+}

src/main.rs

@@ -10,6 +10,7 @@ mod config;
 mod encryption;
 mod generators;
 mod handlers;
+mod logging;
 mod map;
 mod mojang;
 mod packets;
@@ -28,30 +29,25 @@ use generators::generate_key_pair;
 use server::MinecraftServer;
 use tokio::{net::TcpListener, sync::Notify};
 use tokio::{signal, time::timeout};
-use tracing::{error, info};
-
-fn init_logger(level: tracing::Level) {
-    use tracing_subscriber::FmtSubscriber;
-
-    tracing::subscriber::set_global_default(
-        FmtSubscriber::builder()
-            .compact()
-            .with_max_level(level)
-            .without_time()
-            .finish(),
-    )
-    .expect("Fail to set global default subscriber");
-}
+use tracing::{debug, error, info, Level};
+
+use crate::logging::{init_logger, set_log_level, str_to_log_level};
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
     // Set up logger
-    init_logger(tracing::Level::DEBUG);
+    let reload_handle = init_logger(tracing::Level::DEBUG);
 
     // Load config from file
     config::load("config.toml").await?;
     let config = config::get_config().await;
 
+    // Set logging level from config
+    set_log_level(
+        reload_handle,
+        str_to_log_level(&config.global.logging_level).unwrap_or(Level::INFO),
+    );
+
     // Generate key pair
     let keys = Arc::new(generate_key_pair());
     map::init_map();
@@ -105,10 +101,18 @@ async fn main() -> anyhow::Result<()> {
                         let timeout_duration = Duration::from_secs(config.server.timeout);
                         tokio::spawn(async move {
                             // Setting client timeout
-                            timeout(
-                                timeout_duration,
-                                client.run()
-                            ).await.unwrap_or_else(|_| {error!("Connection from {} has been timed out", addr);})
+                            match timeout(timeout_duration, client.run()).await {
+                                Ok(Ok(_)) => {
+                                    debug!("Connection from {} closed successfully", addr)
+                                }
+                                Ok(Err(e)) => {
+                                    let _ = client
+                                        .send_disconnect(config.messages.internal_error.clone())
+                                        .await;
+                                    error!("Internal error occurred: {}", e)
+                                }
+                                Err(e) => error!("Connection from {} has been timed out ({})", addr, e),
+                            }
                         });
                     },
                     Err(e) => {

src/server.rs

@@ -9,8 +9,8 @@ use aes::Aes128;
 use anyhow::{anyhow, Result};
 use bytes::{Buf, BufMut, BytesMut};
 use cfb8::Encryptor;
-use std::{net::SocketAddr, sync::Arc, time::Duration};
-use tokio::net::TcpStream;
+use std::{sync::Arc, time::Duration};
+use tokio::{io, net::TcpStream};
 use tracing::{debug, error, info};
 use uuid::Uuid;
 
@@ -31,11 +31,10 @@ pub struct Session {
     pub secret: Option<Vec<u8>>, // Shared secret,
     pub verify_token: [u8; 4],
     pub cipher: Option<Encryptor<Aes128>>,
-    pub addr: SocketAddr,
 }
 
 impl Session {
-    pub async fn new(addr: SocketAddr) -> Self {
+    pub async fn new() -> Self {
         let config = get_config().await;
 
         Self {
@@ -47,7 +46,6 @@ impl Session {
             secret: None,
             verify_token: generate_verify_token(),
             cipher: None,
-            addr,
         }
     }
 }
@@ -63,30 +61,15 @@ pub struct MinecraftServer {
 impl MinecraftServer {
     pub async fn new(stream: TcpStream, keys: Arc<rsa::RsaPrivateKey>) -> Result<Self> {
         Ok(Self {
-            session: Session::new(stream.peer_addr()?).await,
+            session: Session::new().await,
             buffer: BytesMut::new(),
             config: get_config().await,
             stream,
             keys,
         })
     }
 
-    pub async fn run(&mut self) {
-        match self._run().await {
-            Ok(_) => info!(
-                "Connection from {:?} closed successfully",
-                self.session.addr
-            ),
-            Err(e) => {
-                let _ = self
-                    .send_disconnect(self.config.messages.internal_error.clone())
-                    .await;
-                error!("Internal error occurred: {}", e)
-            }
-        }
-    }
-
-    async fn _run(&mut self) -> Result<()> {
+    pub async fn run(&mut self) -> Result<()> {
         loop {
             self.stream.readable().await?;
             let mut temp_buf = vec![0; 1024];
@@ -100,7 +83,12 @@ impl MinecraftServer {
                     self.buffer.put_slice(&temp_buf[..n]);
                     self.handle_packet().await?;
                 }
-                Err(_) => {}
+                Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
+                    continue;
+                }
+                Err(e) => {
+                    error!("Read error: {}", e)
+                }
             }
             self.buffer.clear();
         }