From f73aa32549743b2967160d38c1622199c41524a4 Mon Sep 17 00:00:00 2001
From: metamuffin <metamuffin@disroot.org>
Date: Tue, 29 Apr 2025 15:19:36 +0200
Subject: aaaaaaa

---
 logic/src/admin/log.rs  | 129 ++++++++++++++++++++++++++++++++++++++++++++++++
 logic/src/admin/mod.rs  |   8 +++
 logic/src/admin/user.rs |  17 +++++++
 logic/src/lib.rs        |   1 +
 4 files changed, 155 insertions(+)
 create mode 100644 logic/src/admin/log.rs
 create mode 100644 logic/src/admin/mod.rs
 create mode 100644 logic/src/admin/user.rs

(limited to 'logic/src')

diff --git a/logic/src/admin/log.rs b/logic/src/admin/log.rs
new file mode 100644
index 0000000..64d23ca
--- /dev/null
+++ b/logic/src/admin/log.rs
@@ -0,0 +1,129 @@
+/*
+    This file is part of jellything (https://codeberg.org/metamuffin/jellything)
+    which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
+    Copyright (C) 2025 metamuffin <metamuffin.org>
+*/
+
+use jellycommon::{
+    api::{LogLevel, LogLine},
+    chrono::Utc,
+};
+use log::Level;
+use std::{
+    collections::VecDeque,
+    sync::{Arc, LazyLock, RwLock},
+};
+use tokio::sync::broadcast;
+
+const MAX_LOG_LEN: usize = 4096;
+
+static LOGGER: LazyLock<Log> = LazyLock::new(Log::default);
+
+pub fn enable_logging() {
+    log::set_logger(&*LOGGER).unwrap();
+    log::set_max_level(log::LevelFilter::Debug);
+}
+
+type LogBuffer = VecDeque<Arc<LogLine>>;
+
+pub struct Log {
+    inner: env_logger::Logger,
+    stream: (
+        broadcast::Sender<Arc<LogLine>>,
+        broadcast::Sender<Arc<LogLine>>,
+    ),
+    log: RwLock<(LogBuffer, LogBuffer)>,
+}
+
+pub fn get_log_buffer(warn: bool) -> VecDeque<Arc<LogLine>> {
+    if warn {
+        LOGGER.log.read().unwrap().1.clone()
+    } else {
+        LOGGER.log.read().unwrap().0.clone()
+    }
+}
+pub fn get_log_stream(warn: bool) -> broadcast::Receiver<Arc<LogLine>> {
+    if warn {
+        LOGGER.stream.0.subscribe()
+    } else {
+        LOGGER.stream.1.subscribe()
+    }
+}
+
+impl Default for Log {
+    fn default() -> Self {
+        Self {
+            inner: env_logger::builder()
+                .filter_level(log::LevelFilter::Warn)
+                .parse_env("LOG")
+                .build(),
+            stream: (
+                tokio::sync::broadcast::channel(1024).0,
+                tokio::sync::broadcast::channel(1024).0,
+            ),
+            log: Default::default(),
+        }
+    }
+}
+impl Log {
+    fn should_log(&self, metadata: &log::Metadata) -> bool {
+        let level = metadata.level();
+        level
+            <= match metadata.target() {
+                x if x.starts_with("jelly") => Level::Debug,
+                x if x.starts_with("rocket::") => Level::Info,
+                _ => Level::Warn,
+            }
+    }
+    fn do_log(&self, record: &log::Record) {
+        let time = Utc::now();
+        let line = Arc::new(LogLine {
+            time,
+            module: record.module_path_static(),
+            level: match record.level() {
+                Level::Error => LogLevel::Error,
+                Level::Warn => LogLevel::Warn,
+                Level::Info => LogLevel::Info,
+                Level::Debug => LogLevel::Debug,
+                Level::Trace => LogLevel::Trace,
+            },
+            message: record.args().to_string(),
+        });
+        let mut w = self.log.write().unwrap();
+        w.0.push_back(line.clone());
+        let _ = self.stream.0.send(line.clone());
+        while w.0.len() > MAX_LOG_LEN {
+            w.0.pop_front();
+        }
+        if record.level() <= Level::Warn {
+            let _ = self.stream.1.send(line.clone());
+            w.1.push_back(line);
+            while w.1.len() > MAX_LOG_LEN {
+                w.1.pop_front();
+            }
+        }
+    }
+}
+
+impl log::Log for Log {
+    fn enabled(&self, metadata: &log::Metadata) -> bool {
+        self.inner.enabled(metadata) || self.should_log(metadata)
+    }
+    fn log(&self, record: &log::Record) {
+        match (record.module_path_static(), record.line()) {
+            // TODO is there a better way to ignore those?
+            (Some("rocket::rocket"), Some(670)) => return,
+            (Some("rocket::server"), Some(401)) => return,
+            _ => {}
+        }
+        if self.inner.enabled(record.metadata()) {
+            self.inner.log(record);
+        }
+        if self.should_log(record.metadata()) {
+            self.do_log(record)
+        }
+    }
+    fn flush(&self) {
+        self.inner.flush();
+    }
+}
diff --git a/logic/src/admin/mod.rs b/logic/src/admin/mod.rs
new file mode 100644
index 0000000..270a732
--- /dev/null
+++ b/logic/src/admin/mod.rs
@@ -0,0 +1,8 @@
+/*
+    This file is part of jellything (https://codeberg.org/metamuffin/jellything)
+    which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
+    Copyright (C) 2025 metamuffin <metamuffin.org>
+*/
+
+pub mod user;
+pub mod log;
diff --git a/logic/src/admin/user.rs b/logic/src/admin/user.rs
new file mode 100644
index 0000000..2d788cb
--- /dev/null
+++ b/logic/src/admin/user.rs
@@ -0,0 +1,17 @@
+/*
+    This file is part of jellything (https://codeberg.org/metamuffin/jellything)
+    which is licensed under the GNU Affero General Public License (version 3); see /COPYING.
+    Copyright (C) 2025 metamuffin <metamuffin.org>
+*/
+
+use crate::session::AdminSession;
+use anyhow::Result;
+use jellybase::database::Database;
+use jellycommon::api::ApiAdminUsersResponse;
+
+pub fn admin_users(db: &Database, _session: &AdminSession) -> Result<ApiAdminUsersResponse> {
+    // TODO dont return useless info like passwords
+    Ok(ApiAdminUsersResponse {
+        users: db.list_users()?,
+    })
+}
diff --git a/logic/src/lib.rs b/logic/src/lib.rs
index a47afc3..1dba95d 100644
--- a/logic/src/lib.rs
+++ b/logic/src/lib.rs
@@ -12,3 +12,4 @@ pub mod search;
 pub mod session;
 pub mod stats;
 pub mod items;
+pub mod admin;
-- 
cgit v1.2.3-70-g09d2