strawberries/slimes-website
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

added cache to prevent the server from blocking itself if too many requests

Browse Source
This commit is contained in:
eiiko6
2026-05-04 20:26:31 +02:00
parent 23d24d81b1
commit 33eb3e4f3f
3 changed files with 162 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files

281
src/handlers.rs
View File

@@ -5,7 +5,7 @@ use axum::{
use chrono::{DateTime, Utc};
use reqwest::StatusCode;
use serde::{Deserialize, Serialize};
use std::{collections::HashMap, sync::Arc};
use std::{collections::HashMap, sync::Arc, time::Instant};
use tera::Context;
use crate::{AppState, TEMPLATES};
@@ -16,7 +16,7 @@ pub struct SortParams {
pub order: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Report {
pub id: u64,
pub mac_address: String,
@@ -44,14 +44,14 @@ pub struct ReportRow {
pub is_new: bool,
}
#[derive(Debug, Serialize, Deserialize)]
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct Benchmark {
pub logical_cores: u32,
pub multi_thread: ScoreDetail,
pub single_thread: ScoreDetail,
}
#[derive(Debug, Serialize, Deserialize)]
#[derive(Debug, Serialize, Deserialize, Clone)]
pub struct ScoreDetail {
pub score: u64,
}
@@ -100,134 +100,9 @@ fn parse_total_ram_raw(ram_str: &str) -> f32 {
digits.parse::<f32>().unwrap_or(0.0) / 1024.0
}
pub async fn home_handler(
State(state): State<Arc<AppState>>,
Query(params): Query<SortParams>,
) -> Result<impl IntoResponse, (StatusCode, String)> {
let response = reqwest::get("https://alatreon.org/slimes?limit=1000")
.await
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
let raw_reports = response.json::<Vec<Report>>().await.map_err(|e| {
(
StatusCode::INTERNAL_SERVER_ERROR,
format!("JSON Error: {}", e),
)
})?;
let mut reports: Vec<ReportRow> = raw_reports
.into_iter()
.map(|s| ReportRow {
id: s.id,
score: (s.benchmark.multi_thread.score + s.benchmark.single_thread.score) / 2,
single_score: s.benchmark.single_thread.score,
multi_score: s.benchmark.multi_thread.score,
cores: s.benchmark.logical_cores,
ram: s
.slimes
.get("RAM")
.and_then(|v| v.first())
.map(|r| parse_total_ram(r))
.unwrap_or_else(|| "-".into()),
ram_raw: s
.slimes
.get("RAM")
.and_then(|v| v.first())
.map(|r| parse_total_ram_raw(r))
.unwrap_or_else(|| 0.0),
os: s
.slimes
.get("OS")
.and_then(|v| v.first())
.cloned()
.unwrap_or_else(|| "Unknown".into()),
hostname: s
.slimes
.get("Hostname")
.and_then(|v| v.first())
.cloned()
.unwrap_or_else(|| "-".into()),
signature: s.signature,
timestamp: s.timestamp.clone(),
time_ago: format_time_ago(&s.timestamp),
is_new: is_recent(&s.timestamp),
})
.collect();
let sort_field = params.sort.unwrap_or_else(|| "score".to_string());
let order = params.order.unwrap_or_else(|| "desc".to_string());
reports.sort_by(|a, b| {
let cmp = match sort_field.as_str() {
"single" => a.single_score.cmp(&b.single_score),
"multi" => a.multi_score.cmp(&b.multi_score),
"ram" => a
.ram_raw
.partial_cmp(&b.ram_raw)
.unwrap_or(std::cmp::Ordering::Equal),
"threads" => a.cores.cmp(&b.cores),
"time" => a.timestamp.cmp(&b.timestamp),
_ => a.score.cmp(&b.score),
};
if order == "asc" { cmp } else { cmp.reverse() }
});
let mut context = Context::new();
context.insert("reports", &reports);
context.insert("title", &state.app_name);
context.insert("current_sort", &sort_field);
context.insert("current_order", &order);
context.insert("current_page", "leaderboard");
context.insert("prefix", "");
match TEMPLATES.render("index.html", &context) {
Ok(html) => Ok(Html(html)),
Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
}
}
pub async fn report_details_handler(
State(state): State<Arc<AppState>>,
Path(id): Path<u64>,
) -> Result<impl IntoResponse, (StatusCode, String)> {
let url = format!("https://alatreon.org/slimes/{}", id);
let report = reqwest::get(url)
.await
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?
.json::<Report>()
.await
.map_err(|e| (StatusCode::NOT_FOUND, format!("Report not found: {}", e)))?;
let mut context = Context::new();
context.insert("report", &report);
context.insert("title", &format!("Report #{} | {}", id, state.app_name));
context.insert("time_ago", &format_time_ago(&report.timestamp));
context.insert(
"score",
&((report.benchmark.multi_thread.score + report.benchmark.single_thread.score) / 2),
);
context.insert("current_page", "details");
context.insert("prefix", "../");
match TEMPLATES.render("details.html", &context) {
Ok(html) => Ok(Html(html)),
Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
}
}
async fn get_processed_reports() -> Result<Vec<ReportRow>, (StatusCode, String)> {
let response = reqwest::get("https://alatreon.org/slimes?limit=10000")
.await
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
let raw_reports = response.json::<Vec<Report>>().await.map_err(|e| {
(
StatusCode::INTERNAL_SERVER_ERROR,
format!("JSON Error: {}", e),
)
})?;
Ok(raw_reports
/// Map raw Report to ReportRow for UI
fn process_reports(raw_reports: Vec<Report>) -> Vec<ReportRow> {
raw_reports
.into_iter()
.map(|s| {
let ram_raw = s
@@ -267,7 +142,137 @@ async fn get_processed_reports() -> Result<Vec<ReportRow>, (StatusCode, String)>
is_new: is_recent(&s.timestamp),
}
})
.collect())
.collect()
}
/// Retrieves reports from cache if fresh, otherwise fetches from API
async fn get_cached_reports(state: &AppState) -> Result<Vec<Report>, (StatusCode, String)> {
{
let cache_read = state.reports_cache.read().await;
if let Some(cache) = &*cache_read {
if cache.updated_at.elapsed() < state.cache_duration {
return Ok(cache.data.clone());
}
}
}
let mut cache_write = state.reports_cache.write().await;
// Double-check?
if let Some(cache) = &*cache_write {
if cache.updated_at.elapsed() < state.cache_duration {
return Ok(cache.data.clone());
}
}
tracing::debug!("Refreshing reports cache from API...");
let response = reqwest::get("https://alatreon.org/slimes?limit=10000")
.await
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
let fresh_reports = response.json::<Vec<Report>>().await.map_err(|e| {
(
StatusCode::INTERNAL_SERVER_ERROR,
format!("JSON Error: {}", e),
)
})?;
// NOTE: to be clear we ARE storing all the reports in RAM
*cache_write = Some(crate::Cache {
data: fresh_reports.clone(),
updated_at: Instant::now(),
});
Ok(fresh_reports)
}
pub async fn home_handler(
State(state): State<Arc<AppState>>,
Query(params): Query<SortParams>,
) -> Result<impl IntoResponse, (StatusCode, String)> {
let raw_reports = get_cached_reports(&state).await?;
let mut reports = process_reports(raw_reports);
let sort_field = params.sort.unwrap_or_else(|| "score".to_string());
let order = params.order.unwrap_or_else(|| "desc".to_string());
reports.sort_by(|a, b| {
let cmp = match sort_field.as_str() {
"single" => a.single_score.cmp(&b.single_score),
"multi" => a.multi_score.cmp(&b.multi_score),
"ram" => a
.ram_raw
.partial_cmp(&b.ram_raw)
.unwrap_or(std::cmp::Ordering::Equal),
"threads" => a.cores.cmp(&b.cores),
"time" => a.timestamp.cmp(&b.timestamp),
_ => a.score.cmp(&b.score),
};
if order == "asc" { cmp } else { cmp.reverse() }
});
let mut context = Context::new();
context.insert("reports", &reports);
context.insert("title", &state.app_name);
context.insert("current_sort", &sort_field);
context.insert("current_order", &order);
context.insert("current_page", "leaderboard");
context.insert("prefix", "");
match TEMPLATES.render("index.html", &context) {
Ok(html) => Ok(Html(html)),
Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
}
}
pub async fn report_details_handler(
State(state): State<Arc<AppState>>,
Path(id): Path<u64>,
) -> Result<impl IntoResponse, (StatusCode, String)> {
// Check if the report exists in our current cache to avoid API call
{
let cache = state.reports_cache.read().await;
if let Some(c) = &*cache {
if let Some(report) = c.data.iter().find(|r| r.id == id) {
return render_details(report.clone(), &state).await;
}
}
}
// Fallback: fetch specifically if not in list
let url = format!("https://alatreon.org/slimes/{}", id);
let report = reqwest::get(url)
.await
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?
.json::<Report>()
.await
.map_err(|e| (StatusCode::NOT_FOUND, format!("Report not found: {}", e)))?;
render_details(report, &state).await
}
async fn render_details(
report: Report,
state: &AppState,
) -> Result<impl IntoResponse + use<>, (StatusCode, String)> {
let mut context = Context::new();
context.insert("report", &report);
context.insert(
"title",
&format!("Report #{} | {}", report.id, state.app_name),
);
context.insert("time_ago", &format_time_ago(&report.timestamp));
context.insert(
"score",
&((report.benchmark.multi_thread.score + report.benchmark.single_thread.score) / 2),
);
context.insert("current_page", "details");
context.insert("prefix", "../");
match TEMPLATES.render("details.html", &context) {
Ok(html) => Ok(Html(html)),
Err(e) => Err((StatusCode::INTERNAL_SERVER_ERROR, e.to_string())),
}
}
#[derive(Serialize)]
@@ -290,7 +295,9 @@ pub struct AnalyticsData {
pub async fn analytics_handler(
State(state): State<Arc<AppState>>,
) -> Result<impl IntoResponse, (StatusCode, String)> {
let reports = get_processed_reports().await?;
let raw_reports = get_cached_reports(&state).await?;
let reports = process_reports(raw_reports);
if reports.is_empty() {
return Err((StatusCode::NOT_FOUND, "No data available".into()));
}
@@ -332,7 +339,6 @@ pub async fn analytics_handler(
})
.or_insert(r.score);
}
let mut os_min_stats: Vec<(String, u64)> = os_min_map.into_iter().collect();
os_min_stats.sort_by(|a, b| b.1.cmp(&a.1));
@@ -343,10 +349,9 @@ pub async fn analytics_handler(
.collect();
os_counts.sort_by(|a, b| b.1.cmp(&a.1));
// Score distribution
// Score distribution
let min_score = reports.iter().map(|r| r.score).min().unwrap_or(0);
let max_score = reports.iter().map(|r| r.score).max().unwrap_or(0);
let range = (max_score - min_score).max(1);
let bin_width = range as f32 / 10.0;
@@ -367,7 +372,7 @@ pub async fn analytics_handler(
dist_counts[bin_idx] += 1;
}
// Ratios
// Efficiency Ratios
let total_reports = reports.len();
let avg_score_per_gb = reports
.iter()

17
src/main.rs
View File

@@ -1,13 +1,17 @@
use axum::{Router, routing::get};
use clap::Parser;
use lazy_static::lazy_static;
use std::sync::Arc;
use std::{
sync::Arc,
time::{Duration, Instant},
};
use tera::Tera;
use tokio::sync::RwLock;
mod handlers;
use handlers::home_handler;
use crate::handlers::{analytics_handler, report_details_handler};
use crate::handlers::{Report, analytics_handler, report_details_handler};
lazy_static! {
pub static ref TEMPLATES: Tera = {
@@ -43,8 +47,15 @@ pub struct Cli {
verbose: bool,
}
pub struct Cache<T> {
pub data: T,
pub updated_at: Instant,
}
struct AppState {
app_name: String,
pub reports_cache: RwLock<Option<Cache<Vec<Report>>>>,
pub cache_duration: Duration,
}
#[tokio::main]
@@ -57,6 +68,8 @@ async fn main() -> anyhow::Result<()> {
let shared_state = Arc::new(AppState {
app_name: "Slimes Leaderboards".to_string(),
reports_cache: RwLock::new(None),
cache_duration: Duration::from_secs(30),
});
let app = Router::new()

10
templates/analytics.html
View File

@@ -232,7 +232,7 @@
position: absolute;
top: 1rem;
right: 1rem;
background: var(--primary-soft);
background: var(--bg-main);
border: 1px solid var(--primary-border);
color: var(--primary-color);
padding: 0.4rem 0.7rem;
@@ -245,8 +245,7 @@
}
.expand-btn:hover {
background: var(--primary-color);
color: white;
background: var(--primary-soft);
}
.modal {
@@ -282,7 +281,7 @@
}
.close-modal {
background: var(--primary-soft);
background: var(--bg-main);
border: 1px solid var(--primary-border);
color: var(--primary-color);
width: 32px;
@@ -296,8 +295,7 @@
}
.close-modal:hover {
background: var(--primary-color);
color: white;
background: var(--primary-soft);
}
.modal-body {