feat: add GetClashLogs method

Author: oomeow

src/client/mod.rs

@@ -1,4 +1,4 @@
-use std::{sync::Arc, time::Duration};
+use std::{collections::VecDeque, sync::Arc, time::Duration};
 
 use anyhow::Result;
 use kode_bridge::{ClientConfig, IpcHttpClient, pool::PoolConfig};
@@ -82,6 +82,16 @@ pub async fn start_clash(body: &ClashConfig) -> Result<Response<()>> {
     Ok(response)
 }
 
+pub async fn get_clash_logs() -> Result<Response<VecDeque<String>>> {
+    let client = connect().await?;
+    let response = client
+        .get(IpcCommand::GetClashLogs.as_ref())
+        .send()
+        .await?
+        .json::<Response<VecDeque<String>>>()?;
+    Ok(response)
+}
+
 pub async fn stop_clash() -> Result<Response<()>> {
     let client = connect().await?;
     let response = client

src/core/command.rs

@@ -7,6 +7,11 @@ pub enum IpcCommand {
     GetVersion,
     // #[strum(serialize = "/clash")]
     // GetClash,
+
+    // 用于日志界面加载上一次日志内容
+    #[strum(serialize = "/clash/logs")]
+    GetClashLogs,
+
     #[strum(serialize = "/clash/start")]
     StartClash,
     #[strum(serialize = "/clash/stop")]

src/core/manager.rs

@@ -5,9 +5,11 @@ use anyhow::Result;
 use flexi_logger::writers::LogWriter;
 use flexi_logger::{DeferredNow, Record};
 use once_cell::sync::Lazy;
+use std::collections::VecDeque;
 use std::process::Stdio;
-use std::sync::Arc;
+use std::sync::{Arc, OnceLock};
 use tokio::io::AsyncBufReadExt;
+use tokio::sync::{RwLock, RwLockReadGuard};
 use tokio::{io::BufReader, process::Command};
 use tokio::{process::Child, sync::Mutex};
 use tracing::{info, warn};
@@ -36,6 +38,39 @@ impl ChildGuard {
     }
 }
 
+const LOGS_QUEUE_LEN: usize = 100;
+
+pub struct ClashLogger {
+    logs: Arc<RwLock<VecDeque<String>>>,
+}
+
+impl ClashLogger {
+    pub fn global() -> &'static ClashLogger {
+        static LOGGER: OnceLock<ClashLogger> = OnceLock::new();
+
+        LOGGER.get_or_init(|| ClashLogger {
+            logs: Arc::new(RwLock::new(VecDeque::with_capacity(LOGS_QUEUE_LEN + 10))),
+        })
+    }
+
+    pub async fn get_logs(&self) -> RwLockReadGuard<'_, VecDeque<String>> {
+        self.logs.read().await
+    }
+
+    pub async fn append_log(&self, text: String) {
+        let mut logs = self.logs.write().await;
+        if logs.len() > LOGS_QUEUE_LEN {
+            logs.pop_front();
+        }
+        logs.push_back(text);
+    }
+
+    pub async fn clear_logs(&self) {
+        let mut logs = self.logs.write().await;
+        logs.clear();
+    }
+}
+
 pub struct CoreManager {
     running_child: Arc<Mutex<Option<ChildGuard>>>,
     running_config: Arc<Mutex<Option<ClashConfig>>>,
@@ -81,6 +116,7 @@ impl CoreManager {
 
     pub async fn stop_core(&mut self) -> Result<()> {
         info!("Stopping core");
+        ClashLogger::global().clear_logs().await;
 
         let child_guard = self.running_child.lock().await.take();
         drop(child_guard);
@@ -176,6 +212,7 @@ pub async fn run_with_logging(
     tokio::spawn(async move {
         let w = shared_writer_clone.lock().await;
         while let Ok(Some(line)) = stdout_reader.next_line().await {
+            ClashLogger::global().append_log(line.clone()).await;
             let mut now = DeferredNow::default();
             let arg = format_args!("{}", line);
             let record = Record::builder()
@@ -192,6 +229,7 @@ pub async fn run_with_logging(
     tokio::spawn(async move {
         let w = shared_writer_clone.lock().await;
         while let Ok(Some(line)) = stderr_reader.next_line().await {
+            ClashLogger::global().append_log(line.clone()).await;
             let mut now = DeferredNow::default();
             let arg = format_args!("{}", line);
             let record = Record::builder()

src/core/server.rs

@@ -1,5 +1,5 @@
 use super::state::IpcState;
-use crate::core::manager::CORE_MANAGER;
+use crate::core::manager::{CORE_MANAGER, ClashLogger};
 use crate::core::structure::Response;
 use crate::{ClashConfig, IpcCommand, VERSION};
 use http::StatusCode;
@@ -200,6 +200,17 @@ fn create_ipc_router() -> Result<Router> {
                     .build()),
             }
         })
+        .get(IpcCommand::GetClashLogs.as_ref(), |_| async move {
+            let json_value = Response {
+                code: 0,
+                message: "Success".to_string(),
+                data: Some(ClashLogger::global().get_logs().await.clone()),
+            };
+            Ok(HttpResponse::builder()
+                .status(StatusCode::OK)
+                .json(&json_value)?
+                .build())
+        })
         .delete(IpcCommand::StopClash.as_ref(), |_| async move {
             match CORE_MANAGER.lock().await.stop_core().await {
                 Ok(_) => info!("Core stopped successfully"),